diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/.classpath b/EcurieJavaApp/Ecurie_ccunatbrule/.classpath new file mode 100644 index 0000000..7ad2bf6 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/.classpath @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/.project b/EcurieJavaApp/Ecurie_ccunatbrule/.project new file mode 100644 index 0000000..6a6ac71 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/.project @@ -0,0 +1,17 @@ + + + Ecurie_ccunatbrule + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/controleur/Cheval.java b/EcurieJavaApp/Ecurie_ccunatbrule/controleur/Cheval.java new file mode 100644 index 0000000..427808b --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/controleur/Cheval.java @@ -0,0 +1,55 @@ +package controleur; + +public class Cheval { + private int id, age; + private String nom, sexe, robe, type, race, proprietaire, image; + public Cheval() + {//ADD + this.id=this.age=0; + this.nom=this.sexe=this.proprietaire=this.robe=this.type=this.image=""; + } + public Cheval (int id, String nom, String sexe, String robe, String type, String race, String proprietaire, int age, String image) + {//ALL + this.id= id; + this.nom = nom; + this.sexe = sexe; + this.robe = robe; + this.type = type; + this.race = race; + this.proprietaire = proprietaire; + this.age = age; + this.image = image; + } + public Cheval (String nom, String sexe, String robe, String type, String race, String proprietaire, int age) + {//ADD + this.nom = nom; + this.sexe = sexe; + this.robe = robe; + this.type = type; + this.race = race; + this.proprietaire = proprietaire; + this.age = age; + } + public Cheval (String nom) + {//DELETE + this.nom = nom; + } + public int getId() { return id; } + public String getNom() { return nom; } + public String getSexe() { return sexe; } + public String getRobe() { return robe; } + public String getType() { return type; } + public String getRace() { return race; } + public String getProprietaire() { return proprietaire; } + public int getAge() { return age; } + public String getImage() { return image; } + public void setId(int id) { this.id = id; } + public void setNom(String nom) { this.nom = nom; } + public void setSexe(String sexe) { this.sexe = sexe; } + public void setRobe(String robe) { this.robe = robe; } + public void setType(String type) { this.type = type; } + public void setRace(String race) { this.race = race; } + public void setProprietaire(String proprietaire) { this.proprietaire = proprietaire; } + public void setAge(int age) { this.age = age; } + public void setImage(String image) { this.image = image; } +} \ No newline at end of file diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/controleur/Cours.java b/EcurieJavaApp/Ecurie_ccunatbrule/controleur/Cours.java new file mode 100644 index 0000000..07047ae --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/controleur/Cours.java @@ -0,0 +1,50 @@ +package controleur; + +public class Cours +{ + private int idcours; + private String datecours, heuredebut, heurefin; + public Cours() + { + this.idcours=0; + this.datecours = this.heuredebut=this.heurefin=""; + } + public Cours (int idcours, String datecours, String heuredebut, String heurefin) + { + this.idcours= idcours; + this.datecours = datecours; + this.heuredebut = heuredebut; + this.heurefin = heurefin; + } + public Cours ( String datecours, String heuredebut, String heurefin) + { + this.idcours= 0; + this.datecours = datecours; + this.heuredebut = heuredebut; + this.heurefin = heurefin; + } + public int getIdCours() { + return idcours; + } + public void setIdCours(int idcours) { + this.idcours = idcours; + } + public String getDateCours() { + return datecours; + } + public void setDateCours(String datecours) { + this.datecours = datecours; + } + public String getHeureDebut() { + return heuredebut; + } + public void setHeureDebut(String heuredebut) { + this.heuredebut = heuredebut; + } + public String getHeureFin() { + return heurefin; + } + public void setHeureFin(String heurefin) { + this.heurefin = heurefin; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/controleur/Eleve.java b/EcurieJavaApp/Ecurie_ccunatbrule/controleur/Eleve.java new file mode 100644 index 0000000..e73fe74 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/controleur/Eleve.java @@ -0,0 +1,66 @@ +package controleur; + +public class Eleve +{ + private int id, privilege, age, galop; + private String record, pseudo, prenom, nom, sexe, adresse, mdp, mail, imageeleve; + public Eleve() {//ALL + this.id=this.privilege=this.age=this.galop=0; + this.record=this.pseudo=this.prenom=this.nom=this.sexe=this.adresse=this.mail=""; + } + public Eleve (int id, int privilege, String record, String pseudo, String prenom, String nom, String sexe, int age, String adresse, String mdp, String mail, int galop, String imageeleve) + {//ALL + this.id= id; + this.privilege = privilege; + this.record = record; + this.pseudo = pseudo; + this.prenom = prenom; + this.nom = nom; + this.sexe = sexe; + this.age = age; + this.adresse = adresse; + this.mdp = mdp; + this.mail = mail; + this.galop = galop; + this.imageeleve = imageeleve; + } + public Eleve (String prenom, String nom, String sexe, int age, String adresse, String mail, int galop) + {//ADD & Modify + this.prenom = prenom; + this.nom = nom; + this.sexe = sexe; + this.age = age; + this.adresse = adresse; + this.mail = mail; + this.galop = galop; + } + public Eleve (String mail) {//DELETE + this.mail = mail; + } + public int getId() { return id; } + public int getPrivilege() { return privilege; } + public String getRecord() { return record; } + public String getPseudo() { return pseudo; } + public String getPrenom() { return prenom; } + public String getNom() { return nom; } + public String getSexe() { return sexe; } + public int getAge() { return age; } + public String getAdresse() { return adresse; } + public String getMdp() { return mdp; } + public String getMail() { return mail; } + public int getGalop() { return galop; } + public String getImageEleve() { return imageeleve; } + public void setid(int id) { this.id = id; } + public void setPrivilege(int privilege) { this.privilege = privilege; } + public void setrecord(String record) { this.record = record; } + public void setPseudo(String pseudo) { this.pseudo = pseudo; } + public void setPrenom(String prenom) { this.prenom = prenom; } + public void setNom(String nom) { this.nom = nom; } + public void setSexe(String sexe) { this.sexe = sexe; } + public void setAge(int age) { this.age = age; } + public void setAdresse(String adresse) { this.adresse = adresse; } + public void setMdp(String mdp) { this.mdp = mdp; } + public void setMail(String mail) { this.mail = mail; } + public void setGalop(int galop) { this.galop = galop; } + public void setImageEleve(String imageeleve) { this.imageeleve = imageeleve; } +} \ No newline at end of file diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/controleur/Formateur.java b/EcurieJavaApp/Ecurie_ccunatbrule/controleur/Formateur.java new file mode 100644 index 0000000..685d64f --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/controleur/Formateur.java @@ -0,0 +1,59 @@ +package controleur; + +public class Formateur +{ + private int idformateur, privilege, age, galop; + private String login, prenom, nom, sexe, mail, mdp ; + public Formateur() + {//ALL + this.idformateur=this.privilege=this.age=this.galop=0; + this.login=this.prenom=this.nom=this.sexe=this.mail=this.mdp=""; + } + public Formateur (int idformateur, String login, int privilege, String prenom, String nom, int age, int galop, String sexe, String mail, String mdp) + {//ALL + this.idformateur= idformateur; + this.login = login; + this.privilege = privilege; + this.prenom = prenom; + this.nom = nom; + this.age = age; + this.galop = galop; + this.sexe = sexe; + this.mail = mail; + this.mdp = mdp; + } + public Formateur(String prenom,String nom, int age, int galop, String sexe, String mail, String mdp) + {//ADD + this.prenom = prenom; + this.nom = nom; + this.age = age; + this.galop = galop; + this.sexe = sexe; + this.mail = mail; + this.mdp = mdp; + } + public Formateur(String mail) + {//DELETE + this.mail = mail; + } + public int getId() { return idformateur; } + public String getLogin() { return login; } + public int getPrivilege() { return privilege; } + public String getPrenom() { return prenom; } + public String getNom() { return nom; } + public int getAge() { return age; } + public int getGalop() { return galop;} + public String getSexe() {return sexe;} + public String getMail() { return mail; } + public String getMdp() { return mdp; } + public void setId(int idformateur) { this.idformateur = idformateur; } + public void setLogin(String login) { this.login = login; } + public void setPrivilege(int privilege) { this.privilege = privilege; } + public void setPrenom(String prenom) { this.prenom = prenom; } + public void setNom(String nom) { this.nom = nom; } + public void setAge(int age) { this.age = age; } + public void setGalop(int galop) {this.galop = galop; } + public void setSexe(String sexe) {this.sexe = sexe; } + public void setMail(String mail) { this.mail = mail; } + public void setMdp(String mdp) { this.mdp = mdp; } +} \ No newline at end of file diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/controleur/Gestion.java b/EcurieJavaApp/Ecurie_ccunatbrule/controleur/Gestion.java new file mode 100644 index 0000000..3e832fd --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/controleur/Gestion.java @@ -0,0 +1,23 @@ +package controleur; + +import vue.Connexion; + +public class Gestion +{ + private static Connexion uneConnexion; + public Gestion() + { + uneConnexion = new Connexion(); + uneConnexion.rendreVisible(true); + } + + public static void rendreVisible(boolean val) + { + uneConnexion.rendreVisible(val); + } + + public static void main(String[] args) + { + new Gestion(); + } +} \ No newline at end of file diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/images/Thumbs.db b/EcurieJavaApp/Ecurie_ccunatbrule/images/Thumbs.db new file mode 100644 index 0000000..fa7bfe5 Binary files /dev/null and b/EcurieJavaApp/Ecurie_ccunatbrule/images/Thumbs.db differ diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/images/choix1.png b/EcurieJavaApp/Ecurie_ccunatbrule/images/choix1.png new file mode 100644 index 0000000..5264cda Binary files /dev/null and b/EcurieJavaApp/Ecurie_ccunatbrule/images/choix1.png differ diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/images/choix2.png b/EcurieJavaApp/Ecurie_ccunatbrule/images/choix2.png new file mode 100644 index 0000000..8b44952 Binary files /dev/null and b/EcurieJavaApp/Ecurie_ccunatbrule/images/choix2.png differ diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/images/choosemyday_logo.png b/EcurieJavaApp/Ecurie_ccunatbrule/images/choosemyday_logo.png new file mode 100644 index 0000000..b886521 Binary files /dev/null and b/EcurieJavaApp/Ecurie_ccunatbrule/images/choosemyday_logo.png differ diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/images/ec_launcher-web.png b/EcurieJavaApp/Ecurie_ccunatbrule/images/ec_launcher-web.png new file mode 100644 index 0000000..7767104 Binary files /dev/null and b/EcurieJavaApp/Ecurie_ccunatbrule/images/ec_launcher-web.png differ diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/images/favicon.png b/EcurieJavaApp/Ecurie_ccunatbrule/images/favicon.png new file mode 100644 index 0000000..1565b40 Binary files /dev/null and b/EcurieJavaApp/Ecurie_ccunatbrule/images/favicon.png differ diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/images/logo.png b/EcurieJavaApp/Ecurie_ccunatbrule/images/logo.png new file mode 100644 index 0000000..aa02a5f Binary files /dev/null and b/EcurieJavaApp/Ecurie_ccunatbrule/images/logo.png differ diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/modele/BDD.java b/EcurieJavaApp/Ecurie_ccunatbrule/modele/BDD.java new file mode 100644 index 0000000..97699d2 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/modele/BDD.java @@ -0,0 +1,52 @@ +package modele; + +import java.sql.Connection; +import java.sql.DriverManager; +import java.sql.SQLException; +import java.sql.Statement; + +public class BDD { + private String serveur, nombdd, user, mdp; + private Connection maConnexion; + + public BDD() { + this.serveur = "localhost"; + this.nombdd = "Ecurie"; + this.user = "USER"; + this.mdp = "MDP"; + this.maConnexion = null; + } + public void chargerPilote() { + // vérifie la présence du pilote JDBC MySQL + try { + Class.forName("org.mariadb.jdbc.Driver"); + } + catch(ClassNotFoundException exp) { + System.out.println("Abscence du pilote JDBC !"); + } + } + public void seConnecter() { + // connexion au serveur de la BDD + this.chargerPilote(); + String url = "jdbc:mariadb://" + this.serveur + "/" + this.nombdd; + try { + this.maConnexion = DriverManager.getConnection(url, this.user, this.mdp); + } + catch(SQLException exp) { + System.out.println("Impossible de se connecter à  " + url); + } + } + public void seDeconnecter() { + // déconnexion au serveur de la BDD + try { + if(this.maConnexion != null) this.maConnexion.close(); + } + catch(SQLException exp) { + System.out.println("La déconnexion a échoué !"); + } + } + public Connection getMaConnexion() + { + return this.maConnexion; + } +} \ No newline at end of file diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/modele/ModeleCheval.java b/EcurieJavaApp/Ecurie_ccunatbrule/modele/ModeleCheval.java new file mode 100644 index 0000000..9a6c6fe --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/modele/ModeleCheval.java @@ -0,0 +1,107 @@ +package modele; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.ArrayList; +import controleur.Cheval; + +public class ModeleCheval { + public static ArrayList selectAll() { + ArrayList lesChevaux = new ArrayList(); + String requete = "select * from Cheval;"; + try { + BDD uneBDD = new BDD(); + uneBDD.seConnecter(); + Statement unStat = uneBDD.getMaConnexion().createStatement(); + ResultSet unRes = unStat.executeQuery(requete); + while(unRes.next()) { + int id = unRes.getInt("idcheval"); + String nom = unRes.getString("nom"); + String sexe = unRes.getString("sexe"); + String robe = unRes.getString("robe"); + String type = unRes.getString("type"); + String race = unRes.getString("race"); + String proprietaire = unRes.getString("proprietaire"); + int age = unRes.getInt("age"); + String image = unRes.getString("imagecheval"); + Cheval unCheval = new Cheval(id, nom, sexe, robe, type, race, proprietaire, age, image); + lesChevaux.add(unCheval); + } + unStat.close(); + unRes.close(); + uneBDD.seDeconnecter(); + } + catch(SQLException exp) { + System.out.println("Erreur d'execution de la requete " + requete); + } + return lesChevaux; + } + public static Cheval selectWhere(String nom) { + String requete = "select * from Cheval where nom='" + nom + "';"; + Cheval unCheval = null; + try { + BDD uneBDD = new BDD(); + uneBDD.seConnecter(); + + Statement unStat = uneBDD.getMaConnexion().createStatement(); + ResultSet unRes = unStat.executeQuery(requete); + if(unRes.next()) { + int id = unRes.getInt("idcheval"); + //Nom + String sexe = unRes.getString("sexe"); + String robe = unRes.getString("robe"); + String type = unRes.getString("type"); + String race = unRes.getString("race"); + String proprietaire = unRes.getString("proprietaire"); + int age = unRes.getInt("age"); + String image = unRes.getString("imagecheval"); + unCheval = new Cheval(id, nom, sexe, robe, type, race, proprietaire, age, image); + } + unStat.close(); + unRes.close(); + uneBDD.seDeconnecter(); + } + catch(SQLException exp) { + System.out.println("Erreur d'execution de la requete " + requete); + } + return unCheval; + } + public static void insert(Cheval unCheval) { + String requete = "insert into Cheval (nom, sexe, robe, type, race, proprietaire, age) values ('" + + unCheval.getNom() + "', '" + + unCheval.getSexe() + "', '" + + unCheval.getRobe() + "', '" + + unCheval.getType() + "', '" + + unCheval.getRace() + "', '" + + unCheval.getProprietaire() + "', '" + + unCheval.getAge() + "');"; + /*+ unCheval.getImage()+ "');";*/ + try { + BDD uneBDD = new BDD(); + uneBDD.seConnecter(); + Statement unStat = uneBDD.getMaConnexion().createStatement(); + unStat.execute(requete); + unStat.close(); + uneBDD.seDeconnecter(); + } + catch(SQLException exp) { + System.out.println("Erreur d'execution de la requete " + requete); + } + } + public static void delete(String nom) { + String requete = "delete from Cheval where nom='" + nom + "';"; + try { + BDD uneBDD = new BDD(); + uneBDD.seConnecter(); + + Statement unStat = uneBDD.getMaConnexion().createStatement(); + unStat.execute(requete); + unStat.close(); + uneBDD.seDeconnecter(); + } + catch(SQLException exp) { + System.out.println("Erreur d'execution de la requete " + requete); + } + } +} \ No newline at end of file diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/modele/ModeleCours.java b/EcurieJavaApp/Ecurie_ccunatbrule/modele/ModeleCours.java new file mode 100644 index 0000000..3d29f8f --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/modele/ModeleCours.java @@ -0,0 +1,95 @@ +package modele; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.ArrayList; +import controleur.Cours; + +public class ModeleCours +{ + public static ArrayList selectAll() + { + ArrayList lesCours = new ArrayList(); + String requete = "select * from Cours;"; + try { + BDD uneBDD = new BDD(); + uneBDD.seConnecter(); + Statement unStat = uneBDD.getMaConnexion().createStatement(); + ResultSet unRes = unStat.executeQuery(requete); + while(unRes.next()) { + int idcours = unRes.getInt("idcours"); + String datecours = unRes.getString("datecours"); + String heuredebut = unRes.getString("heuredebut"); + String heurefin = unRes.getString("heurefin"); + Cours unCours = new Cours(idcours, datecours, heuredebut, heurefin); + lesCours.add(unCours); + } + unStat.close(); + unRes.close(); + uneBDD.seDeconnecter(); + } + catch(SQLException exp) { + System.out.println("Erreur d'execution de la requete " + requete); + } + return lesCours; + } +public static void insert(Cours unCours) +{ + String requete = "insert into Cours (datecours, heuredebut, heurefin ) values ('" + + unCours.getDateCours() + "', '" + + unCours.getHeureDebut() + "', '" + + unCours.getHeureFin() + "');"; + try { + BDD uneBDD = new BDD(); + uneBDD.seConnecter(); + + Statement unStat = uneBDD.getMaConnexion().createStatement(); + unStat.execute(requete); + unStat.close(); + uneBDD.seDeconnecter(); + } + catch(SQLException exp) + { + System.out.println("Erreur d'execution de la requete " + requete); + } +} +public static void delete(String datecours, String heuredebut) { + String requete = "delete from Cours where datecours='" + datecours + "AND heuredebut='" + heuredebut + "';"; + try { + BDD uneBDD = new BDD(); + uneBDD.seConnecter(); + + Statement unStat = uneBDD.getMaConnexion().createStatement(); + unStat.execute(requete); + unStat.close(); + uneBDD.seDeconnecter(); + } + catch(SQLException exp) { + System.out.println("Erreur d'execution de la requete " + requete); + } +} +public static Cours selectWhere(String datecours, String heuredebut) +{ + String requete = "select * from Cours where datecours='" + datecours + "' and heuredebut='" + heuredebut + "';"; + Cours unCours = null; + try { + BDD uneBDD = new BDD(); + uneBDD.seConnecter(); + Statement unStat = uneBDD.getMaConnexion().createStatement(); + ResultSet unRes = unStat.executeQuery(requete); + if(unRes.next()) + { + String heurefin = unRes.getString("heurefin"); + unCours = new Cours(datecours, heuredebut, heurefin); + } + unStat.close(); + unRes.close(); + uneBDD.seDeconnecter(); + } + catch(SQLException exp) { + System.out.println("Erreur d'execution de la requete " + requete); + } + return unCours; + } +} \ No newline at end of file diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/modele/ModeleEleve.java b/EcurieJavaApp/Ecurie_ccunatbrule/modele/ModeleEleve.java new file mode 100644 index 0000000..f74ba07 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/modele/ModeleEleve.java @@ -0,0 +1,151 @@ +package modele; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.ArrayList; +import controleur.Eleve; + +public class ModeleEleve +{ + public static ArrayList selectAll() { + ArrayList lesEleves = new ArrayList(); + String requete = "select * from compteeleve;"; + try { + BDD uneBDD = new BDD(); + uneBDD.seConnecter(); + Statement unStat = uneBDD.getMaConnexion().createStatement(); + ResultSet unRes = unStat.executeQuery(requete); + while(unRes.next()) { + int id = unRes.getInt("ideleve"); + int privilege = unRes.getInt("privilege"); + String record = unRes.getString("dateenregistre"); + String pseudo = unRes.getString("pseudo"); + String prenom = unRes.getString("prenom"); + String nom = unRes.getString("nom"); + String sexe = unRes.getString("sexe"); + int age = unRes.getInt("age"); + String adresse = unRes.getString("adresse"); + String mdp = unRes.getString("mdp"); + String mail = unRes.getString("adressemail"); + int galop = unRes.getInt("galop"); + String image = unRes.getString("imageeleve"); + Eleve unEleve = new Eleve(id, privilege, record, pseudo, prenom, nom, sexe, age, adresse, mdp, mail, galop, image); + lesEleves.add(unEleve); + } + unStat.close(); + unRes.close(); + uneBDD.seDeconnecter(); + } + catch(SQLException exp) { + System.out.println("Erreur d'execution de la requete " + requete); + } + return lesEleves; + } + public static Eleve selectWhere(String mail) { + String requete = "select * from compteeleve where adressemail='" + mail + "';"; + Eleve unEleve = null; + try { + BDD uneBDD = new BDD(); + uneBDD.seConnecter(); + Statement unStat = uneBDD.getMaConnexion().createStatement(); + ResultSet unRes = unStat.executeQuery(requete); + if(unRes.next()) { + int id = unRes.getInt("ideleve"); + int privilege = unRes.getInt("privilege"); + String record = unRes.getString("dateenregistre"); + String pseudo = unRes.getString("pseudo"); + String prenom = unRes.getString("prenom"); + String nom = unRes.getString("nom"); + String sexe = unRes.getString("sexe"); + int age = unRes.getInt("age"); + String adresse = unRes.getString("adresse"); + String mdp = unRes.getString("mdp"); + //adressemail + int galop = unRes.getInt("galop"); + String image = unRes.getString("imageeleve"); + unEleve = new Eleve(id, privilege, record, pseudo, prenom, nom, sexe, age, adresse, mdp, mail, galop, image); + } + unStat.close(); + unRes.close(); + uneBDD.seDeconnecter(); + } + catch(SQLException exp) { + System.out.println("Erreur d'execution de la requete " + requete); + } + return unEleve; + } + public static void insert(Eleve unEleve) { + String requete = "insert into CompteEleve (privilege, dateenregistre, pseudo, prenom, nom, sexe, age, adresse, mdp, adressemail, galop, imageeleve) values ('" + + "2', NOW(), 'NEW', '" + + unEleve.getPrenom() + "', '" + + unEleve.getNom() + "', '" + + unEleve.getSexe() + "', " + + unEleve.getAge() + ", '" + + unEleve.getAdresse() + "', '" + + "CCB', '" + + unEleve.getMail() + "', " + + unEleve.getGalop() + ", '" + + "./images/avatars/img_user.jpg');"; + try { + BDD uneBDD = new BDD(); + uneBDD.seConnecter(); + + Statement unStat = uneBDD.getMaConnexion().createStatement(); + unStat.execute(requete); + unStat.close(); + uneBDD.seDeconnecter(); + } + catch(SQLException exp) { + System.out.println("Erreur d'execution de la requete " + requete); + } + } + public static void update(Eleve unEleve, String mail) { + String valuePrenom = unEleve.getPrenom(); + String valueNom = unEleve.getNom(); + String valueSexe = unEleve.getSexe(); + String valueAge = String.valueOf(unEleve.getAge()); + String valueGalop = String.valueOf(unEleve.getGalop()); + String valueAdresse = unEleve.getAdresse(); + //adressemail + if (unEleve.getPrenom().equals("")) { valuePrenom = ""; } + else { valuePrenom = ", prenom = '"+ unEleve.getPrenom() +"'"; } + if (unEleve.getNom().equals("")) { valueNom = ""; } + else { valueNom = ", nom = '"+ unEleve.getNom() +"'"; } + if (unEleve.getSexe().equals("")) { valueSexe = ""; } + else { valueSexe = ", sexe = '"+ unEleve.getSexe() +"'"; } + if (String.valueOf(unEleve.getAge()).equals("")) { valueAge = ""; } + else { valueAge = ", age = "+ unEleve.getAge(); } + if (unEleve.getAdresse().equals("")) { valueAdresse = ""; } + else { valueAdresse = ", adresse = '"+ unEleve.getAdresse() +"'"; } + if (String.valueOf(unEleve.getGalop()).equals("")) { valueGalop = ""; } + else { valueGalop = ", galop = "+ unEleve.getGalop(); } + String requete = "update compteeleve set adressemail ='"+ unEleve.getMail() +"'" + valuePrenom + valueNom + valueSexe + valueAge + valueAdresse + valueGalop + " where adressemail='"+ mail +"';"; + try { + BDD uneBDD = new BDD(); + uneBDD.seConnecter(); + Statement unStat = uneBDD.getMaConnexion().createStatement(); + unStat.execute(requete); + unStat.close(); + uneBDD.seDeconnecter(); + } + catch(SQLException exp) { + System.out.println("Erreur d'execution de la requete " + requete); + } + } + public static void delete(String mail) { + String requete = "delete from CompteEleve where adressemail='" + mail + "';"; + try { + BDD uneBDD = new BDD(); + uneBDD.seConnecter(); + + Statement unStat = uneBDD.getMaConnexion().createStatement(); + unStat.execute(requete); + unStat.close(); + uneBDD.seDeconnecter(); + } + catch(SQLException exp) { + System.out.println("Erreur d'execution de la requete " + requete); + } + } +} \ No newline at end of file diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/modele/ModeleFormateur.java b/EcurieJavaApp/Ecurie_ccunatbrule/modele/ModeleFormateur.java new file mode 100644 index 0000000..d61ba37 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/modele/ModeleFormateur.java @@ -0,0 +1,109 @@ +package modele; + +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Statement; +import java.util.ArrayList; +import controleur.Formateur; + +public class ModeleFormateur +{ + public static ArrayList selectAll() { + ArrayList lesFormateurs = new ArrayList(); + String requete = "select * from Formateur;"; + try { + BDD uneBDD = new BDD(); + uneBDD.seConnecter(); + Statement unStat = uneBDD.getMaConnexion().createStatement(); + ResultSet unRes = unStat.executeQuery(requete); + while(unRes.next()) { + int idformateur = unRes.getInt("idformateur"); + String login = unRes.getString("login"); + int privilege = unRes.getInt("privilege"); + String prenom = unRes.getString("prenom"); + String nom = unRes.getString("nom"); + int age = unRes.getInt("age"); + int galop = unRes.getInt("galop"); + String sexe = unRes.getString("sexe"); + String mail = unRes.getString("adressemail"); + String mdp = unRes.getString("mdp"); + Formateur unFormateur = new Formateur(idformateur, login, privilege, prenom, nom, age, galop, sexe, mail, mdp); + lesFormateurs.add(unFormateur); + } + unStat.close(); + unRes.close(); + uneBDD.seDeconnecter(); + } + catch(SQLException exp) { + System.out.println("Erreur d'execution de la requete " + requete); + } + return lesFormateurs; + } + public static Formateur selectWhere(String mail, String mdp) { + String requete = "select * from Formateur where adressemail='" + mail + "' and mdp='" + mdp + "';"; + Formateur unFormateur = null; + try { + BDD uneBDD = new BDD(); + uneBDD.seConnecter(); + Statement unStat = uneBDD.getMaConnexion().createStatement(); + ResultSet unRes = unStat.executeQuery(requete); + if(unRes.next()) + { + int idformateur = unRes.getInt("idformateur"); + String login = unRes.getString("login"); + int privilege = unRes.getInt("privilege"); + String prenom = unRes.getString("prenom"); + String nom = unRes.getString("nom"); + int age = unRes.getInt("age"); + int galop = unRes.getInt("galop"); + String sexe = unRes.getString("sexe"); + // adressemail & mdp + unFormateur = new Formateur(idformateur, login, privilege, prenom, nom, age, galop, sexe, mail, mdp); + } + unStat.close(); + unRes.close(); + uneBDD.seDeconnecter(); + } + catch(SQLException exp) { + System.out.println("Erreur d'execution de la requete " + requete); + } + return unFormateur; + } + public static void insert(Formateur unFormateur) { + String requete = "insert into Formateur (login, privilege, prenom, nom, age, galop, sexe, adressemail, mdp) values ('" + + unFormateur.getLogin() + "', '" + + unFormateur.getPrivilege() + "', '" + + unFormateur.getPrenom() + "', '" + + unFormateur.getNom() + "', '" + + unFormateur.getAge() + "', '" + + unFormateur.getGalop() + "', '" + + unFormateur.getSexe() + "', '" + + unFormateur.getMail() + "', '" + + unFormateur.getMdp() + "');"; + try { + BDD uneBDD = new BDD(); + uneBDD.seConnecter(); + Statement unStat = uneBDD.getMaConnexion().createStatement(); + unStat.execute(requete); + unStat.close(); + uneBDD.seDeconnecter(); + } + catch(SQLException exp) { + System.out.println("Erreur d'execution de la requete " + requete); + } + } + public static void delete(String mail) { + String requete = "delete from Formateur where adressemail='" + mail + "';"; + try { + BDD uneBDD = new BDD(); + uneBDD.seConnecter(); + Statement unStat = uneBDD.getMaConnexion().createStatement(); + unStat.execute(requete); + unStat.close(); + uneBDD.seDeconnecter(); + } + catch(SQLException exp) { + System.out.println("Erreur d'execution de la requete " + requete); + } + } +} \ No newline at end of file diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/CHANGES b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/CHANGES new file mode 100644 index 0000000..2b839ae --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/CHANGES @@ -0,0 +1,6089 @@ +# Changelog +# https://dev.mysql.com/doc/relnotes/connector-j/8.0/en/ + +Version 8.0.26 + + - Fix for Bug#32954396, EXECUTEQUERY HANGS WITH USECURSORFETCH=TRUE & SETFETCHSIZE. + + - Fix for Bug#102372 (32459408), v8.0.23 unusable in OSGi. + + - Fix for Bug#25554464, CONNECT FAILS WITH NPE WHEN THE SERVER STARTED WITH CUSTOM COLLATION. + + - Fix for Bug#100606 (31818423), UNECESARY CALL TO "SET NAMES 'UTF8' COLLATE 'UTF8_GENERAL_CI'". + Thanks to Marc Fletcher for his contribution. + + - Fix for Bug#102404 (32435618), CONTRIBUTION: ADD TRACK SESSION STATE CHANGE. + Thanks to William Lee for his contribution. + + - Fix for Bug#95280 (29757140), DATABASEMETADATA.GETIMPORTEDKEYS RETURNS DOUBLE THE ROWS. + Thanks to Miron Balcerzak for his contribution. + + - Fix for Bug#97269 (30438500), POSSIBLE BUG IN COM.MYSQL.CJ.XDEVAPI.STREAMINGDOCRESULTBUILDER. + + - Fix for Bug#103303 (32766143), JAVA.LANG.CLASSCASTEXCEPTION WHEN INSERTING BLOB WITH SERVER PREPARED STATEMENT. + + - WL#14205, Support query attributes. + + - WL#14411, Support for authentication_kerberos_client authentication plugin. + + - WL#14559, Deprecate TLS 1.0 and 1.1. + + - WL#14391, Migrate QA tests to main repo. + +Version 8.0.25 + + - This release contains no functional changes and is published to align the version number with the MySQL Server 8.0.25 release. + +Version 8.0.24 + + - Fix for Bug#102188 (32526663), AccessControlException with AuthenticationLdapSaslClientPlugin. + + - Fix for Bug#22508715, SETSESSIONMAXROWS() CALL ON CLOSED CONNECTION RESULTS IN NPE. + + - Fix for Bug#102131 (32338451), UPDATABLERESULTSET NPE WHEN USING DERIVED QUERIES OR VIEWS. + + - Fix for Bug#101596 (32151143), GET THE 'HOST' PROPERTY ERROR AFTER CALLING TRANSFORMPROPERTIES() METHOD. + + - Fix for Bug#20391832, SETOBJECT() FOR TYPES.TIME RESULTS IN EXCEPTION WHEN VALUE HAS FRACTIONAL PART. + + - Fix for Bug#97730 (31699993), xdev api: ConcurrentModificationException at Session.close. + + - Fix for Bug#99708 (31510398), mysql-connector-java 8.0.20 ASSERTION FAILED: Unknown message type: 57 s.close. + + - Fix for Bug#32122553, EXTRA BYTE IN COM_STMT_EXECUTE. + + - Fix for Bug#101558 (32141210), NULLPOINTEREXCEPTION WHEN EXECUTING INVALID QUERY WITH USEUSAGEADVISOR ENABLED. + + - Fix for Bug#102076 (32329915), CONTRIBUTION: MYSQL JDBC DRIVER RESULTSET.GETLONG() THROWS NUMBEROUTOFRANGE. + + - Fix for Bug#31747910, BUG 30474158 FIX IMPROVES JDBC COMPLIANCE BUT CHANGES DEFAULT RESULTSETTYPE HANDLING. + + - Fix for Bug#102321 (32405590), CALLING RESULTSETMETADATA.GETCOLUMNCLASSNAME RETURNS WRONG VALUE FOR DATETIME. + + - WL#14453, Pluggable authentication: new default behavior & user-less authentications. + + - WL#14392, Improve timeout error messages [classic]. + + - WL#14202, XProtocol: Support connection close notification. + +Version 8.0.23 + + - Fix for Bug#21789378, FORCED TO SET SERVER TIMEZONE IN CONNECT STRING. + + - Fix for Bug#95644 (30573281), JDBC GETDATE/GETTIME/GETTIMESTAMP INTERFACE BEHAVIOR CHANGE AFTER UPGRADE 8.0. + + - Fix for Bug#94457 (29402209), CONNECTOR/J RESULTSET.GETOBJECT( ..., OFFSETDATETIME.CLASS ) THROWS. + + - Fix for Bug#76775 (20959249), FRACTIONAL SECONDS IN TIME VALUES ARE NOT AVAILABLE VIA JDBC. + + - Fix for Bug#99013 (31074051), AN EXTRA HOUR GETS ADDED TO THE TIMESTAMP WHEN SUBTRACTING INTERVAL 'N' DAYS. + + - Fix for Bug#98695 (30962953), EXECUTION OF "LOAD DATA LOCAL INFILE" COMMAND THROUGH JDBC FOR DATETIME COLUMN. + + - Fix for Bug#101413 (32099505), JAVA.TIME.LOCALDATETIME CANNOT BE CAST TO JAVA.SQL.TIMESTAMP. + + - Fix for Bug#101242 (32046007), CANNOT USE BYTEARRAYINPUTSTREAM AS ARGUMENTS IN PREPARED STATEMENTS ANYMORE. + Thanks to Martynas Puronas for his contribution. + + - WL#14274, Support for authentication_ldap_sasl_client(SCRAM-SHA-256) authentication plugin. + + - WL#14206, Support for authentication_ldap_sasl_client(GSSAPI) authentication plugin. + + - WL#14207, Replace language in APIs and source code/docs. + +Version 8.0.22 + + - Fix for Bug#98667 (31711961), "All pipe instances are busy" exception on multiple connections to named Pipe. + + - Fix for Bug#96309 (31699357), MultiHost in loadbalance may lead to a TPS reduction during a quick switch. + + - Fix for Bug#99076 (31083755), Unclear exception/error when connecting with jdbc:mysql to a mysqlx port. + + - Fix for Bug#96870 (30304764), Contribution: Allow to disable AbandonedConnectionCleanupThread completely. + Thanks to Andrey Turbanov for his contribution. + + - WL#14115, Support for authentication_ldap_sasl_client(SCRAM-SHA-1) authentication plugin. + + - WL#14096, Add option to specify LOAD DATA LOCAL allow list folder. + + - WL#13780, Skip system-wide trust and key stores (incl. X DevAPI client certs). + + - WL#14017, XProtocol -- support for configurable compression algorithms. + + - Fix for Bug#92903 (28834903), MySQL Connector/j should support wildcard names or alternative names. + + - Fix for Bug#99767 (31443178), Contribution: Check SubjectAlternativeName for TLS instead of commonName. + Thanks to Daniël van Eeden for his contribution. + + - Fix for Bug#93444 (29015453), LOCALDATETIME PARAMETER VALUES ALTERED WHEN CLIENT AND SERVER TIMEZONES DIFFER. + Thanks to Iwao Abe for his contribution. + + - WL#14052, Remove asynchronous variant of X Protocol. + + - Fix for Bug#99713 (31418928), NPE DURING COM.MYSQL.CJ.SERVERPREPAREDQUERYBINDVALUE.STOREDATE(). + + - WL#14068, Remove legacy integration with JBoss. + +Version 8.0.21 + + - WL#14051, Upgrade Protocol Buffers dependency to protobuf-java-3.11.4. + + - WL#14042, Upgrade testsuite to JUnit 5. + + - Fix for Bug#98237 (30911870), PREPAREDSTATEMENT.SETOBJECT(I, "FALSE", TYPES.BOOLEAN) ALWAYS SETS TRUE OR 1. + + - WL#13008, DevAPI: Add schema validation to create collection. + +Version 8.0.20 + + - Fix for Bug#30805426, IN CASE OF ISAUTHMETHODSWITCHREQUESTPACKET , TOSERVERS > 1 ARE IGNORED. + + - Fix for Bug#97714 (30570249), Contribution: Expose elapsed time for query interceptor to avoid hacky thread local implementations. + Thanks to Matti Sillanpää and Johnathan Crawford for their contribution. + + - Fix for Bug#97724 (30570721), Contribution: Allow \'3.\' formatted numbers. + Thanks to Nick Pollett for his contribution. + + - Fix for Bug#98536 (30877755), SIMPLEDATEFORMAT COULD CACHE A WRONG CALENDAR. + + - Fix for Bug#91112 (28125069), AGAIN WRONG JAVA.SQL.DATE. + + - Fix for Bug#30474158, CONNECTOR/J 8 DOES NOT HONOR THE REQUESTED RESULTSETTYPE SCROLL_INSENSITIVE ETC. + + - Fix for Bug#98445 (30832513), Connection option clientInfoProvider=ClientInfoProviderSP causes NPE. + + - WL#12248, DevAPI: Connection compression. + + - Fix for Bug#30636056, ResultSetUtil.resultSetToMap() can be unsafe to use. + + - Fix for Bug#97757 (30584907), NULLPOINTEREXCEPTION WITH CACHERESULTSETMETADATA=TRUE AND EXECUTEQUERY OF "SET". + +Version 8.0.19 + + - WL#13346, Support for mult-host and failover. + + - Fix for Bug#97413 (30477722), DATABASEMETADATA IS BROKEN AFTER SERVER WL#13528. + + - WL#13367, DNS SRV support. + + - WL#12736, DevAPI: Specify TLS ciphers to be used by a client or session. + + - Fix for regression tests broken by Bug#97079 fix. + + - Fix for Bug#96383 (30119545) RS.GETTIMESTAMP() HAS DIFFERENT RESULTS FOR TIME FIELDS WITH USECURSORFETCH=TRUE. + + - Fix for Bug#96059 (29999318), ERROR STREAMING MULTI RESULTSETS WITH MYSQL-CONNECTOR-JAVA 8.0.X. + + - Fix for Bug#96442 (30151808), INCORRECT DATE ERROR WHEN CALLING GETMETADATA ON PREPARED STATEMENT. + +Version 8.0.18 + + - WL#13347, Connectors should handle expired password sandbox without SET operations. + + - Fix for Bug#84098 (25223123), endless loop in LoadBalancedAutoCommitInterceptor. + + - Fix for Bug#23721537, MULTI-SELECT WITH EXECUTEASYNC() GIVES IMPROPER ERROR. + + - Fix for Bug#95741 (29898567), METADATA QUERY USES UPPER() AROUND NUMERIC EXPRESSION. + + - Fix for Bug#20913289, PSTMT.EXECUTEUPDATE() FAILS WHEN SQL MODE IS NO_BACKSLASH_ESCAPES. + + - Fix for Bug#80441 (22850444), SYNTAX ERROR ON RESULTSET.UPDATEROW() WITH SQL_MODE NO_BACKSLASH_ESCAPES. + +Version 8.0.17 + + - WL#13210, Generate Javadocs via ant. + + - WL#12247, DevAPI: indexing array fields. + + - WL#12726, DevAPI: Add overlaps and not_overlaps as operator. + + - Fix for Bug#95503 (29821029), Operator IN not mapping consistently to the right X Plugin operation. + + - WL#12942, Update README.md and add new CONTRIBUTING.md. + + - WL#13125, Support fully qualified hostnames longer than 60 characters. + + - Fix for Bug#95210 (29807741), ClassCastException in BlobFromLocator when connecting as jdbc:mysql:replication. + + - Fix for Bug#29591275, THE JAR FILE NEEDS TO CONTAIN A README AND LICENSE FILE. + + - WL#13124, Support new utf8mb4 bin collation. + + - WL#13009, DevAPI: Deprecate methods. + + - WL#11101, Remove de-cache and close of SSPSs on double call to close(). + + - Fix for Bug#89133 (27356869) CONTRIBUTION: UPDATE DATABASEMETADATA.JAVA. + Thanks to Harald Aamot for his contribution. + + - Fix for Bug#11891000, DABATASEMETADATA.GETTABLES() IGNORES THE SCHEMA_PATTERN ARGUMENT. + + - Fix for Bug#94101 (29277648), SETTING LOGSLOWQUERIES SHOULD NOT AUTOMATICALLY ENABLE PROFILESQL FOR QUERIES. + Thanks to Florian Agsteiner for the contribution. + + - Fix for Bug#74690 (20010454), PROFILEREVENT HOSTNAME HAS NO GETTER(). + + - Fix for Bug#70677 (17640628), CONNECTOR J WITH PROFILESQL - LOG CONTAINS LOTS OF STACKTRACE DATA. + + - Fix for Bug#41172 (11750577), PROFILEREVENT.PACK() THROWS ARRAYINDEXOUTOFBOUNDSEXCEPTION. + + - Fix for Bug#27453692, CHARACTERS GET GARBLED IN CONCAT() IN PS WHEN USECURSORFETCH=TRUE. + + - Fix for Bug#94585 (29452669), GETTABLENAME() RETURNS NULL FOR A QUERY HAVING COUNT(*) WITH JDBC DRIVER V8.0.12. + + - Fix for Bug#94533 (29446100), GETOBJECT FOR BOXED PRIMITIVE TYPES DOESN'T RETURN NULL FOR NULL COLUMNS. + + - Fix for Bug#94442 (29446059), RESULTSETIMPL.GETDOUBLE IS INEFFICIENT BECAUSE OF BIGDECIMAL (RE)CONSTRUCTIONS. + +Version 8.0.16 + + - WL#12825, Remove third-party libraries from sources and bundles. + + - Fix for Bug#93590 (29054329), javax.net.ssl.SSLException: closing inbound before receiving peer's close_notify. + + - Fix for Bug#94414 (29384853), Connector/J RPM package have version number in path. + + - Fix for Bug#27786499, REDUNDANT FILES IN DEBIAN PACKAGE FOR DEBIAN9(COMMUNITY PACKAGE) FOR CJAVA. + + - WL#12246, DevAPI: Prepared statement support. + + - WL#10839, Adjust c/J tests to the new "ON" default for explicit_defaults_for_timestamp. + + - Fix for Bug#29329326, PLEASE AVOID SHOW PROCESSLIST IF POSSIBLE. + + - WL#12460, DevAPI: Support new session reset functionality. + + - WL#12459, DevAPI: Support connection-attributes. + + - Fix for Bug#25650385, GETBYTE() RETURNS ERROR FOR BINARY() FLD. + + - Fix for Bug#27784363, MYSQL 8.0 JDBC DRIVER THROWS NUMBERFORMATEXCEPTION FOR TEXT DATA + + - Fix for Bug#93007 (28860051), LoadBalancedConnectionProxy.getGlobalBlacklist bug. + + - Fix for Bug#29186870, CONNECTOR/J REGRESSION: NOT RETURNING PRECISION GETPROCEDURECOLUMNS. + + - Fix for Bug#22038729, X DEVAPI: ANY API CALL AFTER A FAILED CALL PROC() RESULTS IN HANG. + + - Fix for Bug#29244101, ADD MAPPING FOR UTF8MB4_ZH_0900_AS_CS COLLATION. + + - Fix for Bug#92819 (28834959), EXPRPARSER THROWS WRONGARGUMENTEXCEPTION WHEN PARSING EMPTY JSON ARRAY. + + - Fix for Bug#21921956, X DEVAPI: EXPRESSION PARSE ERROR WITH UNARY OPERATOR. + + - Fix for Bug#94031 (29257922), WRONG JSON_UNQUOTE WORKAROUND. + + - Fix for Bug#22931700, BINDINGS.GETBOOLEAN() ALWAYS RETURNS FALSE. + + - Fix for Bug#25650912, ERROR MESSAGE NOT CLEAR WHEN WE PASS A CHAR DATA TO ANY TABLE API. + + - Fix for Bug#25642021, CHANGEUSER() FAILS WHEN ENABLEPACKETDEBUG=TRUE. + +Version 8.0.15 + + - Fix for Bug#94051 (29261254), Not recommended default for 'allowLoadLocalInfile'. + +Version 8.0.14 + + - WL#12298, Connectors: Expose metadata about source and binaries in unified way. + + - Fix for Bug#93111 (28894344), ConnectionUrl.java contains char U+00A7 (section sign). + + - WL#12621, DevAPI: Handling of Default Schema. + + - Fix for Bug#93340 (28970166), C/J BUILD SCRIPT IS TOO VERBOSE + + - WL#12462, DevAPI: Be prepared for initial notice on connection. + + - Fix for Bug#28924137, WL#12463:IF COLLECTION DOESN'T EXIST, COLL.COUNT() IS GIVING A WRONG ERROR MESSAGE. + + - WL#12463, DevAPI: Standardize count method. + + - Fix for Bug#92508 (28747636), mysql-connector in bootclasspath causing memory leak. + + - Fix for Bug#25650514, UPDATEROW() CALL FAILS WITH NPE WHEN SSPS=TRUE AND TABLE HAS MULTI-FLD KEY. + + - Fix for Bug#25650482, REFRESHROW() CALL AFTER UPDATEROW() API FAILS WHEN USESERVERPREPSTMTS=TRUE. + + - Fix for Bug#92536 (28692243), UPDATEING SERVER SIDE PREPSTMTS RESULTSET FAIL. + + - Fix for Bug#92625 (28731795), CONTRIBUTION: FIX OBSERVED NPE IN CLEARINPUTSTREAM. + Thanks to Henning Schmiedehausen for his contribution. + + - Fix for Bug#23045642, ADDING NO-DOC (MYSQLCONNJ-696) RESULTS IN EXCEPTION. + + - Fix for Bug#91065 (28101003), ZERODATETIMEBEHAVIOR=CONVERT_TO_NULL SHOULD NOT APPLY TO 00:00:00 TIME COLUMNS. + + - Fix for Bug#92574 (28706219), WHEN CONVERTING FROM VARCHAR TO JAVA BOOLEAN, 'N' IS NOT SUPPORTED. + + - Fix for Bug#25642226, CHANGEUSER() NOT SETTING THE DATABASE PROPERLY WITH SHA USER. + + - Fix for Bug#28606708, NAMED PIPE CONNECTION FOR X PROTOCOL RETURNS NPE, EXPECTED PROPER ERROR MESSAGE. + +Version 8.0.13 + + - Fix for Bug#91317 (28207422), Wrong defaults on collation mappings. + + - WL#12245, DevAPI: Implement connect timeout. + + - Fix for Bug#21774249, UNIT TEST FAILS WITH ERROR " 'CEST' IS UNRECOGNIZED TIME ZONE". + + - WL#11857, DevAPI: Implement connection pooling for xprotocol. + + - Fix for Bug#91873 (28444461), REMOVE USEOLDUTF8BEHAVIOR CONNECTION PROPERTY. + + - Fix for Bug#92264 (28594434), JSONPARSER PUTS UNNECESSARY MAXIMUM LIMIT ON JSONNUMBER TO 10 DIGITS. + + - WL#12110, Extend PropertyDefinitions.PropertyKey usage. + + - Fix for Bug#81063 (23098159), w/ rewriteBatchedStatements, when 2 tables involved, the rewriting not correct. + + - Fix for Bug#84813 (25501750), rewriteBatchedStatements fails in INSERT. + + - Fix for Bug#81196 (23227334), CONNECTOR/J NOT FOLLOWING DATABASE CHARACTER SET. + + - Fix for Bug#72609 (18749544), SETDATE() NOT USING A PROLEPTIC GREGORIAN CALENDAR. + + - Fix for Bug#87534 (26730196), UNION ALL query fails when useServerPrepStmts=true on database connection. + Test case only. Base bug fixed in MySQL 5.7.22. + + - Fix for Bug#89948 (27658489), Batched statements are not committed for useLocalTransactionState=true. + + - Fix for BUG#22305979, WRONG RECORD UPDATED IF SENDFRACTIONALSECONDS=FALSE AND SMT IS SCROLLABLE. + + - Fix for Bug#27102307, CHANGE USESSL AND VERIFYSERVERCERTIFICATE TO SSLMODE OPTION. + + - Fix for Bug#28150662, CONNECTOR/J 8 MALFORMED DATABASE URL EXCEPTION WHIT CORRECT URL STRING. + + - Fix for Bug#91421 (28246270), ALLOWED VALUES FOR ZERODATETIMEBEHAVIOR ARE INCOMPATIBLE WITH NETBEANS. + + - Fix for Bug#23045604, XSESSION.GETURI() RETURNS NPE. + + - Fix for Bug#21914769, NPE WHEN TRY TO EXECUTE INVALID JSON STRING. + + - Fix for Bug#BUG#90887 (28034570), DATABASEMETADATAUSINGINFOSCHEMA#GETTABLES FAILS IF METHOD ARGUMENTS ARE NULL. + + - Fix for Bug#28207088, C/JAVA: UPDATECLOB(INT COLUMNLABEL, JAVA.SQL.CLOB CLOB) IS FAILING. + + - Fix for Bug#27629553, NPE FROM GETSESSION() FOR SSL CONNECTION WHEN NO PASSWORD PASSED. + +Version 8.0.12 + + - Fix for Bug#28208000, MASTER : HANG IN ASYNCHRONOUS SELECT TEST. + + - WL#10544, Update MySQL 8.0 keywords list. + + - WL#11858, DevAPI: Core API v1 alignment. + + - Fix for Bug#27652379, NPE FROM GETSESSION(PROPERTIES) WHEN HOST PARAMETER IS GIVEN IN SMALL LETTER. + + - Fix for BUG#87600 (26724154), CONNECTOR THROWS 'MALFORMED DATABASE URL' ON NON MYSQL CONNECTION-URLS. + + - Fix for BUG#26089880, GETCONNECTION("MYSQLX://..") RETURNS NON-X PROTOCOL CONNECTION. + + - WL#11876, Improve connection properties design. + + - WL#11933, Connector/J 8.0 X DevAPI reference documentation update. + + - WL#11860, Ensure >= 75% code coverage. + + - Fix for Bug#90753 (27977617), WAIT_TIMEOUT EXCEEDED MESSAGE NOT TRIGGERED. + + - Fix for Bug#85941 (25924324), WASNULL NOT SET AFTER GETBYTES IS CALLED. + + - Fix for Bug#28066709, COLLECTION.CREATEINDEX() TEST IS BROKEN AFTER WL#11808 IMPLEMENTATION. + + - Fix for Bug#90872 (28027459), FILTERPARAMS CLASS IS NOT NEEDED. + + - Fix for Bug#27522054, POSSIBLE ASYNC XPROTOCOL MESSAGE HANDLING PERF ISSUE. + The "xdevapi.useAsyncProtocol" connection property default value is changed to "false". + +Version 8.0.11 + + - WL#11293, DevAPI: Support new locking modes : NOWAIT and SKIP LOCKED. + + - Fix for Bug#90029 (27678308), FAILURE WHEN GETTING GEOMCOLLECTION COLUMN TYPE. + + - Fix for BUG#90024 (27677574), SOME TESTS FAILED AGAINST MYSQL 8.0.5 BECAUSE OF DEPRECATED FEATURES REMOVAL. + + - Fix for Bug#86741 (26314325), Multi-Host connection with autocommit=0 getAutoCommit maybe wrong. + + - Fix for Bug#27231383, PROVIDE MAVEN-FRIENDLY COMMERCIAL PACKAGES WITHOUT "-BIN". + + - Fix for Bug#26819691, SETTING PACKETDEBUGBUFFERSIZE=0 RESULTS IN CONNECTION FAILURE. + + - Fix for Bug#88227 (27029657), Connector/J 5.1.44 cannot be used against MySQL 5.7.20 without warnings. + + - Fix for Bug#27374581, CONNECTION FAILS WHEN GPL SERVER STARTED WITH TLS-VERSION=TLSV1.2. + + - WL#11419, DevAPI: New document _id generation support. + + - WL#11620, Change caching_sha2_password padding. + + - WL#11604, DevAPI: Add SHA256_MEMORY support. + + - Fix for BUG#86278 (26092824), SUPPORT CUSTOM CONSTRUCTION OF SSLSOCKET DURING CONNECTION ESTABLISHMENT. + + - Fix for BUG#27226293, JSONNUMBER.GETINTEGER() & NUMBERFORMATEXCEPTION. + + - WL#10527, Clean up Protocol and Session interfaces. + +Version 8.0.10 + + - (Skipped version number to align versions between components and server) + +Version 8.0.9 + + - WL#11469, Update license header in GPL packages. + + - Fix for BUG#27247349, WL#11208 : UNIQUE DOES NOT GIVE ERROR EVEN THOUGH IT IS NOT SUPPORTED. + + - WL#11208, DevAPI: Collection.createIndex. + + - WL#10156, Add setters/getters for connection properties to MysqlDataSource, MysqlXADataSource and MysqlConnectionPoolDataSource. + + - WL#11401, DevAPI: Remove configuration API. + Partial revert of "WL#9868, DevAPI: Configuration handling interface." + + - WL#10619, Ensure compatibility with new data dictionary. + + - Fix for BUG#27217264, WL#10937: NULL POINTER EXCEPTION WHEN NULL IS PASSED AS _ID IN COLL.REPLACEONE. + + - WL#10937, DevAPI: ReplaceOne, AddOrReplaceOne, GetOne, RemoveOne. + + - Fix for Bug#26723646, JSON_MERGE() FUNCTION IS DEPRECATED IN MYSQL 8.0. + + - Fix for Bug#27185332, WL#11210:ERROR IS THROWN WHEN NESTED EMPTY DOCUMENTS ARE INSERTED TO COLLECTION. + + - Fix for Bug#27151601, WL#11210: DOCUMENT PATCH EXPRESSIONS ARE NOT SUPPORTED. + + - WL#11210, DevAPI: Modify/MergePatch. + + - Fix for Bug#79612 (22362474), CONNECTION ATTRIBUTES LOST WHEN CONNECTING WITHOUT DEFAULT DATABASE. + + - WL#10152, Enable TLSv1.2 on mysqlx. + + - Fix for Bug#27131768, NULL POINTER EXCEPTION IN CONNECTION. + + - Fix for Bug#88232 (27047676), c/J does not rollback transaction when autoReconnect=true. + + - Fix for Bug#88242 (27040063), autoReconnect and socketTimeout JDBC option makes wrong order of client packet. + + - Fix for Bug#88021 (26939943), High GC pressure when driver configured with serversideprepared statements. + Thanks to Johnathan Crawford for his contribution. + + - Fix for Bug#26724085, CHARSET MAPPING TO BE UPDATED FOR MYSQL 8.0.3. + + - Fix for Bug#87704 (26771560), THE STREAM GETS THE RESULT SET ?THE DRIVER SIDE GET WRONG ABOUT GETLONG(). + + - Fix for Bug#24924097, SERVER GREETING ERROR ISN'T RECOGNIZED DURING HANDSHAKE. + + - Fix for Bug#26748909, MASTER : ERROR - NO OPERATIONS ALLOWED AFTER STATEMENT CLOSED FOR TOSTRING(). + + - Fix for Bug#26266731, CONCUR_UPDATABLE RESULTSET OPERATIONS FAIL AGAINST 8.0 FOR BOOLEAN COLUMN. + + - WL#11239, DevAPI: Remove create table implementation. + + - Fix for Bug#27131100, WL#11212 : SAVEPOINT CREATING WITH EMPTY STRING AND SPACE AS NAME. + + - WL#11212, DevAPI: transaction save-points. + + - WL#11060, Support new SHA-256 authentication system. + + - Fix for Bug#87826 (26846249), MYSQL JDBC CONNECTOR/J DATABASEMETADATA NULL PATTERN HANDLING IS NON-COMPLIANT. + + - WL#11163, Extract parameter setters, serverPrepare() and serverExecute() to core classes. + + - Fix for BUG#26995710, WL#11161 : NULL POINTER EXCEPTION IN EXECUTEBATCH() AND CLOSE(). + + - WL#11161, Unify query bindings. + + - WL#8469, Don't extract query text from packets when possible. + +Version 8.0.8 + + - Fix for BUG#26722030, TEST FAILING DUE TO BINARY LOGGING ENABLED BY DEFAULT IN MYSQL 8.0.3. + + - Fix for BUG#26722018, TESTS FAILING DUE TO CHANGE IN INFORMATION_SCHEMA.INNODB_SYS_* NAMING. + + - Fix for BUG#26750807, MASTER : NULL POINTER EXCEPTION IN SCHEMA.DROPVIEW(NULL). + + - Fix for BUG#26750705, MASTER : ERROR - UNSUPPORTED CONVERSION FROM TIME TO JAVA.SQL.DATE. + + - WL#10620, DevAPI: SHA256 Authentication support. + + - WL#10936, DevAPI: Row locking for Crud.Find. + + - WL#9868, DevAPI: Configuration handling interface. + + - WL#10935, DevAPI: Array or Object "contains" operator. + + - WL#9875, Prepare c/J 8.0 for DEB and RPM builds. + + - Fix for BUG#26259384, CALLABLE STATEMENT GIVES ERROR IN C/JAVA WHEN RUN AGAINST MYSQL 8.0. + + - Fix for Bug#26393132, NULLPOINTEREXCEPTION IS THROWN WHEN TRIED TO DROP A NULL COLLECTION. + + - WL#10532, DevAPI: Cleanup Drop APIs. + + - Fix for Bug#87429 (26633984), repeated close of ServerPreparedStatement causes memory leak. + Thanks to Eduard Gurskiy for his contribution. + + - Fix for Bug#87379 (26646676), Perform actual TLS capabilities check when restricting TLSv1.2. + Thanks to Todd Farmer for his contribution. + + - Fix for Bug#85601 (25777822), Unit notation is missing in the description of the property involved in the time. + + - Fix for Bug#87153 (26501245), INCORRECT RESULT OF DBMD.GETVERSIONCOLUMNS() AGAINST MYSQL 8.0.2+. + + - Fix for Bug#78313 (21931572), proxies not handling Object.equals(Object) calls correctly. + + - Fix for Bug#85885 (25874048), resultSetConcurrency and resultSetType are swapped in call to prepareStatement. + + - Fix for Bug#74932 (20066806), ConnectionImp Doesn't Close Server Prepared Statement (PreparedStatement Leak). + + - WL#10536, Deprecating COM_SHUTDOWN. + + - Fix for Bug#25946965, UPDATE THE TIME ZONE MAPPINGS WITH LATEST TZ DATABASES. + + - Fix for Bug#20182108, INCLUDE CUSTOM LOAD BALANCING STRATEGY USING PLUGIN API. + New load-balancing strategy "serverAffinity" and new connection property "serverAffinityOrder" added. + + - Fix for Bug#26440544, CONNECTOR/J SHOULD NOT USE TX_{READ_ONLY,ISOLATION} WHICH IS PLANNED FOR REMOVAL. + + - Fix for Bug#26399958, UNABLE TO CONNECT TO MYSQL 8.0.3. + + - Fix for Bug#25650305, GETDATE(),GETTIME() AND GETTIMESTAMP() CALL WITH NULL CALENDAR RETURNS NPE. + +Version 8.0.7 + + - Fix for Bug#26227653, WL#10528 DIFF BEHAVIOUR WHEN SYSTEM PROP JAVAX.NET.SSL.TRUSTSTORETYPE IS SET. + + - WL#10528, DevAPI: Ensure all connectors are secure by default. + + - WL#8305, Remove internal dependency on connection objects. + + - Fix for Bug#22972057, X DEVAPI: CLIENT HANGS AFTER CONNECTION FAILURE. + + - Fix for Bug#26140577, GIS TESTS ARE FAILING WITH MYSQL 8.0.1. + + - WL#10765, DevAPI: Forbid modify() and remove() with no condition. + + - Fix for Bug#26090721, CONNECTION FAILING WHEN SERVER STARTED WITH COLLATION UTF8MB4_DE_PB_0900_AI_CI. + + - WL#10781, enum-based connection properties. + + - Fix for Bug#73775 (19531384), DBMD.getProcedureColumns()/.getFunctionColumns() fail to filter by columnPattern. + + - Fix for Bug#84324 (25321524), CallableStatement.extractProcedureName() not work when catalog name with dash. + + - Fix for Bug#79561 (22333996), NullPointerException when calling a fully qualified stored procedure. + + - Fix for Bug#84783 (25490163), query timeout is not working(thread hang). + + - Fix for Bug#70704 (17653733), Deadlock using UpdatableResultSet. + + - Fix for Bug#66430 (16714868), setCatalog on connection leaves ServerPreparedStatement cache for old catalog. + + - Fix for Bug#70808 (17757070), Set sessionVariables in a single query. + + - Fix for Bug#77192 (21170603), Description for the Property replicationConnetionGroup Missing from the Manual. + + - Fix for Bug#83834 (25101890), Typo in Connector/J error message. + + - WL#10531, Support utf8mb4 as default charset. + + - Fix for Bug#85555 (25757019), useConfigs Can't find configuration template named, in mysql-connector-java 6.x + + - WL#10529, Move version number to 8.0. + + - WL#10530, DevAPI: Remove XSession, rename NodeSession to Session. + + - Fix for Bug#23510958, CONCURRENT ASYNC OPERATIONS RESULT IN HANG. + + - Fix for Bug#23597281, GETNODESESSION() CALL WITH SSL PARAMETERS RETURNS CJCOMMUNICATIONSEXCEPTION. + + - Fix for Bug#25207784, C/J DOESN'T FOLLOW THE FINAL X DEVAPI MY-193 SPECIFICATION. + + - Fix for Bug#25494338, ENABLEDSSLCIPHERSUITES PARAMETER NOT WORKING AS EXPECTED WITH X-PLUGIN. + + - Fix for Bug#84084 (25215008), JAVA.LANG.ARRAYINDEXOUTOFBOUNDSEXCEPTION ON ATTEMPT TO GET VALUE FROM RESULTSET. + + - WL#10553, Add mapping for Japanese utf8mb4 collation. + + - Fix for Bug#25575103, NPE FROM CREATETABLE() WHEN SOME OF THE INPUTS ARE NULL. + + - Fix for Bug#25575156, NPE FROM CREATEVIEW() WHEN SOME OF THE INPUTS ARE NULL. + + - Fix for Bug#25636947, CONNECTION USING MYSQL CLIENT FAILS IF WE USE THE SSL CERTIFICATES FROM C/J SRC. + + - Fix for Bug#25687718, INCORRECT TIME ZONE IDENTIFIER IN STATEMENTREGRESSIONTEST. + + - Fix for Bug#25556597, RESULTSETTEST.TESTPADDING UNIT TEST IS FAILING IN 5.1.41 RELEASE PACKAGE. + + - Fix for Bug#25517837, CONNECT PERFORMNACE DEGRADED BY 10% IN 5.1.41. + + - Fix for Bug#25504578, CONNECT FAILS WHEN CONNECTIONCOLLATION=ISO-8859-13. + + - Fix for Bug#25438355, Improper automatic deserialization of binary data. + + - Fix for Bug#70785 (17756825), MySQL Connector/J inconsistent init state for autocommit. + Property 'elideSetAutoCommits' is temporarily disabled due to Bug#66884. Defaults to 'false' until this bug is fixed. + + - Fix for Bug#75615 (21181249), Incorrect implementation of Connection.setNetworkTimeout(). + + - Fix for Bug#81706 (23535001), NullPointerException in driver. + + - Fix for Bug#83052 (25048543), static method in com.mysql.jdbc.Util relies on null object. + + - Fix for Bug#69526 (17035755), 'Abandoned connection cleanup thread' at mysql-connector-java-5.1.25. + + - Fix for Bug#82826 (24942672), Unneeded version requirement for javax.net.ssl Import-Package on OSGi MANIFEST.MF. + +Version 6.0.6 + + - Added Core TLS/SSL options for the mysqlx URI scheme. + + - Updated collations map. + + - Fix for Bug#24350526, UNEXPECTED BEHAVIOUR OF IS_NUMBER_SIGNED API IN C/JAVA. + + - Fix for Bug#82707 (24512766), WRONG MILLI SECOND VALUE RETURNED FROM TIMESTAMP COLUMN. + + - Fix for Bug#82005 (23702040), JDBCDATEVALUEFACTORY FAILS TO PARSE SOME DATES. + + - Fix for Bug#83725 (25056803), NPE IN XPROTOCOL.GETPLUGINVERSION() WITH MYSQL 5.7.17. + + - Fix for Bug#24525461, UPDATABLE RESULTSET FEATURE FAILS WHEN USESERVERPREPSTMTS=TRUE. + + - Fix for Bug#24527173, QUERY EXECUTION USING PREPARED STMT FAILS WHEN USECURSORFETCH=TRUE. + + - Fix for Bug#82964 (24658016), JSR-310 DATA TYPES CREATED THROUGH JAVA.SQL TYPES. + + - Fix for Bug#81202 (23188159), RESULTSETIMPL.GETOBJECT THROWS NULLPOINTEREXCEPTION WHEN FIELD IS NULL. + + - Fix for Bug#22931277, COLUMN.GETTYPE() RETURNS ERROR FOR VALID DATATYPES. + + - Fix for BUG#24471057, UPDATE FAILS WHEN THE NEW VALUE IS OF TYPE DBDOC WHICH HAS ARRAY IN IT. + + - Fix for Bug#81691 (23519211), GETLASTDOCUMENTIDS() DOESN'T REPORT IDS PROVIDED BY USER. + + - Fix for Bug#82826 (24942672), Unneeded version requirement for javax.net.ssl Import-Package on OSGi MANIFEST.MF. + +10-21-16 - Version 6.0.5 + + - Fix for BUG#82896 (24613062), Unexpected behavior on attempt to connect to JDBC driver with unsupported URL. + + - Added client-side failover during XSession initialization for multi-router configuration. + + - Removed Extension interface. All extension classes now implement their specific interfaces. + + - Fix for Bug#22988922, GETLENGTH() RETURNS -1 FOR LONGBLOB AND LONGTEXT FIELDS. + + - Fix for Bug#24619829, NEW FAILURES IN C/JAVA UNITTESTS AGAINST MYSQL 8.0. + + - Fix for Bug#75209 (20212882), Set useLocalTransactionState may result in partially committed transaction. + + - Fix for Bug#48346 (11756431), Communications link failure when reading compressed data with compressed=true. + Thanks to Ryosuke Yamazaki for his contribution. + + - Fix for Bug#80631 (22891845), ResultSet.getString return garbled result with json type data. + Thanks to Dong SongLing for his contribution. + + - Fix for Bug#64188 (13702433), MysqlXAConnection.MYSQL_ERROR_CODES_TO_XA_ERROR_CODES is missing XA error codes. + + - Fix for Bug#72632 (18759269), NullPointerException for invalid JDBC URL. + + - Fix for Bug#82115 (23743956), Some exceptions are intercepted twice or fail to set the init cause. + + - Fix for Bug#78685 (21938551), Wrong results when retrieving the value of a BIT column as an integer. + + - Fix for Bug#80615 (22954007), prepared statement leak when rewriteBatchedStatements=true and useServerPrepStmt. + + - Extended X DevAPI with flexible parameter lists. + + - Added a virtual NodeSession to X DevAPI. + +09-05-16 - Version 6.0.4 + + - X DevAPI URL prefix changed from "mysql:x:" to "mysqlx:". + + - Fix for Bug#24301468 X DEVAPI SSL CONNECTION FAILS ON WINDOWS + + - The X DevAPI Table object now represents both database tables and views. + + - Added support for matching against pattern for X DevAPI list_objects calls. + Added Schema.getCollections(String pattern) and Schema.getTables(String pattern) interface methods. + + - Switched to "mysqlx" namespace for X DevAPI StmtExecute messages. This change is incompatible to MySQL server versions < 5.7.14. + + - Fix for Bug#82046 (23743947), MYSQL CONNECTOR JAVA OSGI METADATA BROKEN. + + - Fix for Bug#21690043, CONNECT FAILS WHEN PASSWORD IS BLANK. + + - Fix for Bug#22931433, GETTING VALUE OF BIT COLUMN RESULTS IN EXCEPTION. + +06-17-16 - Version 6.0.3 + + - Fix for Bug#23535571, EXCESSIVE MEMORY USAGE WHEN ENABLEPACKETDEBUG=TRUE. + + - Fix for Bug#23212347, ALL API CALLS ON RESULTSET METADATA RESULTS IN NPE WHEN USESERVERPREPSTMTS=TRUE. + + - Fix for Bug#23201930, CLIENT HANG WHEN RSLT CUNCURRENCY=CONCUR_UPDATABLE AND RSLTSET TYPE=FORWARD_ONLY. + + - Fix for Bug#23188498, CLIENT HANG WHILE USING SERVERPREPSTMT WHEN PROFILESQL=TRUE AND USEIS=TRUE. + + - Fix for Bug#22678872, NPE DURING UPDATE WITH FABRIC. + New property 'loadBalanceHostRemovalGracePeriod' sets the grace period when removing hosts from a load-balanced connection. + + - Fix for Bug#71131 (18068303), Poor error message in CallableStatement.java. + + - Fix for Bug#59462 (16736619), ConcurrentModificationException inside ConnectionImpl.closeAllOpenStatements(). + + - Fix for Bug#22848249, LOADBALANCECONNECTIONGROUPMANAGER.REMOVEHOST() NOT WORKING AS EXPECTED. + + - Fix for Bug#22730682, ARRAYINDEXOUTOFBOUNDSEXCEPTION FROM CONNECTIONGROUPMANAGER.REMOVEHOST(). + + - Fix for Bug#77171 (21181466), On every connect getting sql_mode from server creates unnecessary exception. + + - Fix for Bug#79343 (22353759), NPE in TimeUtil.loadTimeZoneMappings causing server time zone value unrecognized. + + - Fix for Bug#22038729, X DevAPI: Any API call after a failed CALL PROC() results in hang + + - Remove Schema.drop(), Collection.drop() and replaced with X DevAPI's session.dropSchema() and session.dropCollection(). + Also added session.dropTable(). + + - Fix for Bug#22932078, GETTIMESTAMP() RETURNS WRONG VALUE FOR FRACTIONAL PART + + - Extracted packet readers from MysqlaProtocol. + + - Fix for Bug#22972057, X protocol CLIENT HANGS AFTER CONNECTION FAILURE + + - Fix for Bug#23044312, NullPointerException in X protocol AsyncMessageReader due to race condition + + - Returned support for MySQL 5.5 and 5.6. + +04-05-16 - Version 6.0.2 + + - Deprecate the EOF packet. + + - Fix for Bug#75956, Inserting timestamps using a server PreparedStatement and useLegacyDatetimeCode=false + + - Fix for Bug#22385172, CONNECTOR/J MANIFEST DOES NOT EXPOSE FABRIC (OSGi). + + - Fix for Bug#22598938, FABRICMYSQLDATASOURCE.GETCONNECTION() NPE AFTER SWITCHOVER. + + - Merged version 5.1.38. + + - Fix for Bug#21286268, CONNECTOR/J REPLICATION USE MASTER IF SLAVE IS UNAVAILABLE. + + - Fix for Bug#21296840 & Bug#17910835, Server information in a group from Fabric is not refreshed after expired TTL. + + - Fix for Bug#56122 (11763419), JDBC4 functionality failure when using replication connections. + + - Added support for TLSv1.1 and TLSv1.2 + + - Fix for Bug#78961 (22096981), Can't call MySQL procedure with InOut parameters in Fabric environment. + + - Fix for Bug#56100 (11763401), Replication driver routes DML statements to read-only slaves. + + - StandardSSLSocketFactory implements SocketMetadata. + + - Fix for Bug#21978216, GETTYPEINFO REPORT MAXIMUM PRECISION OF 255 FOR VARBINARY. + + - Fix for Bug#78706 (21947042), Prefer TLS where supported by MySQL Server. + + - Fix for Bug#21934573, FABRIC CODE INVOLVED IN THREAD DEADLOCK. + Duplicate: Bug#78710 (21966391), Deadlock on ReplicationConnection and ReplicationConnectionGroup when failover. + + - Merged version 5.1.37. + + - Fix for Bug#21876798, CONNECTOR/J WITH MYSQL FABRIC AND SPRING PRODUCES PROXY ERROR. + +10-19-15 - Version 6.0.1 + + - Removed useJvmCharsetConverters connection property. JVM charset converters are now used in all cases. + + - Refactored value decoding and removed all date/time connection properties + + - Refactored connection properties + + - Assume existence of INFORMATION_SCHEMA.PARAMETERS (and thus MySQL 5.5) when preparing stored procedure calls. + + - Removed retainStatementAfterResultSetClose connection property. + + - Null-merge of Bug#54095 (11761585) fix. + + - Removed support code for MySQL server versions < 5.7. + + - Merged version 5.1.37. + + - Fix for Bug#76859 (20969312), DBMD getColumns using I_S doesn't have column IS_GENERATEDCOLUMN as per JDBC 4.1. + Added support for GENERATED COLUMNS. + + - Update Time Zone mappings with IANA Time Zone database tsdata2015f and Unicode CLDR v.28. + + - Update DatabaseMetaData SQL keywords. + + - Added tests for Optimizer hints syntax introduced in MySQL 5.7.7. + + - Fix for Bug#21860833, JSON DATA TYPE DOESN'T WORK WITH SSPS. + Added support for JSON data type. + + - Added support for JDBC 4.2 new features. + New property 'enableEscapeProcessing' sets the default escape processing behavior for Statement objects. + + - Fix for Bug#16634180, LOCK WAIT TIMEOUT EXCEEDED CAUSES SQLEXCEPTION, SHOULD CAUSE SQLTRANSIENTEXCEPTION + + - Fix for Bug#75849 (20536592), NPE in abortInternal() method on line 1358 of ConnectionImpl. + + - Fix for Bug#78106 (21648826), Potential memory leak with inflater. + + - Fix for Bug#78225 (21697684), DEFAULT NO_AUTO_CREATE_USER SQL_MODE BEHAVIOR BROKE SOME TESTS + + - Fix for Bug#77665 (21415165), JDBC fails to connect with MySQL 5.0. + + - Fix for Bug#77681 (21429909), rewrite replace sql like insert when rewriteBatchedStatements=true (contribution). + Thanks to Jie Han for his contribution. + + - Fix for Bug#77449 (21304726) Add 'truncateFractionalSeconds=true|false' property (contribution). + The property 'sendFractionalSeconds' was added instead of the proposed 'truncateFractionalSeconds'. + Thanks to KwonNam for his contribution. + + - Fix for Bug#50348 (11758179), mysql connector/j 5.1.10 render the wrong value for dateTime column in GMT DB. + + - Fix for Bug#75670 (20433047), Connection fails with "Public Key Retrieval is not allowed" for native auth. + + - Fix for Bug#76187 (20675539), getTypeInfo report maximum precision of 255 for varchar. + + - Merged version 5.1.36. + + - Add test for new syntax 'ALTER TABLE ... DISCARD|IMPORT PARTITION ...' introduced in MySQL 5.7.4. + + - Fix for Bug#20727196, GETPROCEDURECOLUMNS() RETURNS EXCEPTION FOR FUNCTION WHICH RETURNS ENUM/SET TYPE. + + - Fix for Bug#19803348, GETPROCEDURES() RETURNS INCORRECT OUTPUT WHEN USEINFORMATIONSCHEMA=FALSE. + + - Fix for Bug#21215151, DATABASEMETADATA.GETCATALOGS() FAILS TO SORT RESULTS. + + - Fix for Bug#72630 (18758686), NullPointerException during handshake in some situations + + - Fix for Bug#20825727, CONNECT FAILURE WHEN TRY TO CONNECT SHA USER WITH DIFFERENT CHARSET. + + - Flag RowDataDynamic.isInterrupted removed as it isn't needed. + + - Fix for Bug#20518653, XSL FILES IN PACKAGES + + - Fix for Bug#20804635, GETTIME() AND GETDATE() FUNCTIONS FAILS WHEN FRACTIONAL PART EXISTS + + - Fix for Bug#62452 (16444069), NPE thrown in JDBC4MySQLPooledException when statement is closed. + + - Fix for BUG#70927 (17810800), Connector/J COM_CHANGE_USER handling is broken + + - Fix for Bug#75335 (20283655), Maven artifact for Connector/J is missing source jar. + + - Fix for BUG#75592 (20408891), "SHOW VARIABLES WHERE" is expensive. + + - Fix for Bug#75113 (20821888), Fail in failover of the connection in MySQL fabric + + - Fix for Bug#72077 (18425861), Fabric connection with username to a server with disabled auth throws NPE + + - Add test for already fixed Bug#72546 (18719760), C/J Fabric createGroup() throws ClassCastException + + - Fix for Bug#77217 (21184949), ClassCastException when executing a streaming PreparedStatement with Fabric + + - Merged version 5.1.35. + + - Fix for Bug#19536760, GETSTRING() CALL AFTER RS.RELATIVE() RETURNS NULLPOINTEREXCEPTION + + - Fix for BUG#20453712, CLOB.SETSTRING() WITH VALID INPUT RETURNS EXCEPTION + + - Fix for BUG#20453671, CLOB.POSITION() API CALL WITH CLOB INPUT RETURNS EXCEPTION + + - Fix for Bug#20685022, SSL CONNECTION TO MYSQL 5.7.6 COMMUNITY SERVER FAILS. + + - Fix for Bug#20606107, TEST FAILURES WHEN RUNNING AGAINST 5.7.6 SERVER VERSION + + - Fix for Bug#20533907, BUG#20204783 FIX EXPOSES WRONG BEAHAVIORS IN FAILOVER CONNECTIONS. + This fix is a refactoring of the default failover feature which is no longer attached to load-balancing support. + + - Fix for Bug#20504139, GETFUNCTIONCOLUMNS() AND GETPROCEDURECOLUMNS() RETURNS ERROR FOR VALID INPUTS. + + - Expose PreparedStatment.ParseInfo for external usage, with no capture of the connection, which allows for global, highly-concurrent parse caches to be + implemented. + + - Fix for Bug#75309 (20272931), mysql connector/J driver in streaming mode will in the blocking state. + + - New property 'readOnlyPropagatesToServer' controls the implicit propagation of read only transaction access mode to server. + + - Fix for Bug#54095 (11761585), Unnecessary call in newSetTimestampInternal. + Test case only. The bug was fixed as a consequence of the patch for Bug#71084. + + - Fix for Bug#67760 (15936413), Deadlock when concurrently executing prepared statements with Timestamp objects. + + - Fix for Bug#71084 (18028319), Wrong java.sql.Date stored if client and server time zones differ. + Two connection properties added, "noTimezoneConversionForDateType" and "cacheDefaultTimezone", to define if and how time zone conversions are available to + DATE data type values. + + - Fix for Bug#75080 (20217686), NullPointerException during setTimestamp on Fabric connection. + + - Fix for Bug#75168 (20204783), loadBalanceExceptionChecker interface cannot work using JDBC4/JDK7. + + - Fix for Bug#73595 (19465516), Replace usage of StringBuffer in JDBC driver. + + - Fix for Bug#18925727, SQL INJECTION IN MYSQL JDBC DRIVER. + + - Fix for Bug#74998 (20112694), readRemainingMultiPackets not computed correctly for rows larger than 16 MB. + + - Merged version 5.1.34. + + - Fix for Bug#73012 (19219158), Precedence between timezone options is unclear. + + - Implement support for connecting through SOCKS proxies (WL#8105). Connection properties supporting this are socksProxyHost, socksProxyPort. + + - Ant buildfile reworked to fix incompatibilities with latest Eclipse, to remove dependency from ant-contrib and to improve structure and documentation. + + - Fix for Bug#18474141, TESTSUITE.FABRIC TEST CASES FAIL IF NO FABRIC.TESTSUITE PROPERTIES PROVIDED + + - Fix for Bug#19383371, CONNECT USING MYSQL_OLD_PASSWORD USER FAILS WHEN PWD IS BLANK + + - Merged version 5.1.33. + + - Fix for Bug#17441747, C/J DOESN'T SUPPORT XA RECOVER OUTPUT FORMAT CHANGED IN MYSQL 5.7. + Test case was disabled for affected server versions 5.7.0 - 5.7.4. + + - Fix for Bug#19145408, Error messages may not be interpreted according to the proper character set + + - Fix for Bug#19505524, UNIT TEST SUITE DOES NOT CONSIDER ALL THE PARAMETERS PASSED TO BUILD.XML. + + - Fix for Bug#73474 (19365473), Invalid empty line in MANIFEST.MF + + - Fix for Bug#70436 (17527948), Incorrect mapping of windows timezone to Olson timezone. + TimeZone mappings were revised in order to use latest data from IANA Time Zone Database and Unicode CLDR. + + - Fix for Bug73163 (19171665), IndexOutOfBoundsException thrown preparing statement. + Regression test added. Fix was included in patch from 5.1.32: "Fix for failing tests when running test suite with Java 6+". + + - Added support for gb18030 character set + + - Fix for Bug#73663 (19479242), utf8mb4 does not work for connector/j >=5.1.13 + + - Fix for Bug#73594 (19450418), ClassCastException in MysqlXADataSource if pinGlobalTxToPhysicalConnection=true + + - Fix for Bug#19354014, changeUser() call results in "packets out of order" error when useCompression=true. + + - Fix for Bug#73577 (19443777), CHANGEUSER() CALL WITH USECOMPRESSION=TRUE COULD LEAD TO IO FREEZE + + - Fix for Bug#19172037, TEST FAILURES WHEN RUNNING AGAINST 5.6.20 SERVER VERSION + + - Merged version 5.1.32 + + - Fix for Bug#71923 (18344403), Incorrect generated keys if ON DUPLICATE KEY UPDATE not exact. + Additionally several methods in StringUtils were fixed/upgraded. + + - Fix for Bug#72502 (18691866), NullPointerException in isInterfaceJdbc() when using DynaTrace + + - Fix for Bug#72890 (18970520), Java jdbc driver returns incorrect return code when it's part of XA transaction. + + - Fabric client now supports Fabric 1.5. Older versions are no longer supported. + + - Fix for Bug#71672 (18232840), Every SQL statement is checked if it contains "ON DUPLICATE KEY UPDATE" or not. + Thanks to Andrej Golovnin for his contribution. + + - Fix for Bug#73070 (19034681), Preparing a stored procedure call with Fabric results in an exception + + - Fix for Bug#73053 (19022745), Endless loop in MysqlIO.clearInputStream due to Linux kernel bug. + In the source of this issue is a Linux kernel bug described in the patch "tcp: fix FIONREAD/SIOCINQ" + (https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/commit/?id=a3374c4). + + - Fix for Bug#18869381, CHANGEUSER() FOR SHA USER RESULTS IN NULLPOINTEREXCEPTION + + - Fix for Bug#62577 (16722757), XA connection fails with ClassCastException + + - Fix for Bug#18852587, CONNECT WITH A USER CREATED USING SHA256_PASSWORD PLUGIN FAILS WHEN PWD IS BLANK + + - Fix for Bug#18852682, TEST TESTSHA256PASSWORDPLUGIN FAILS WHEN EXECUTE AGAINST COMMERCIAL SERVER + + - Fix for failing tests when running test suite with Java 6+. + Includes fix for Bug#35829 (11748301), build.xml check for java6 should use or instead of and. + + - Charset mappings refactored. + + - Fix for Bug#72712 (18836319), No way to configure Connector JDBC to not do extra queries on connection + +06-09-14 - Version 5.1.31 + + - Fix for Bug#66947 (16004987), Calling ServerPreparedStatement.close() twice corrupts cached statements. + + - Fix for Bug#61213 (18009254), ON DUPLICATE KEY UPDATE breaks generated key list when extended INSERT is used + + - Test cases updated to comply with MySQL 5.7.4 new STRICT_MODE behavior and no longer supported IGNORE clause in + ALTER TABLE statement. + + - Added support for sha256_password authentication with RSA encryption. + + - Fix for Bug#71753 (18260918), Bad SSL socket transform. + + - Added tests for changes in GET DIAGNOSTIC syntax introduced in MySQL 5.7.0. + + - Fix for Bug#67803 (16708231), XA commands sent twice to MySQL server. + Thanks to Andrej Golovnin for his contribution. + + - Fix for Bug#55680 (16737192), MySQL Connector/J memory leak + + - Fix for Bug#72326 (18598665), Typo in fullDebug.properties - gatherPerMetrics should be gatherPerfMetrics + + - Fix for Bug#72023 (18403456), Avoid byte array creation in MysqlIO#unpackBinaryResultSetRow. + Thanks to Andrej Golovnin for his contribution. + + - Fix for Bug#72000 (18402873), java.lang.ArrayIndexOutOfBoundsException on java.sql.ResultSet.getInt(String). + + - Fix for Bug#71850 (18318197), init() is called twice on exception interceptors + + - Fix for Bug#72008 (18389973), Avoid useless object creation in StringUtils#getBytes-methods. + Thanks to Andrej Golovnin for his contribution. + + - Fix for Bug#72006 (18403199), Avoid creation of a character array in PreparedStatement$ParseInfo. + Thanks to Andrej Golovnin for his contribution. + Additionally, unneeded StringBuffer replaced by StringBuilder instances in StringUtils. + + - Fix for Bug#72301 (18549472), Fabric driver swallows exceptions thrown during connection creation using JDBC4 + +03-28-14 - Version 5.1.30 + + - Fix for Bug#71679 (18236388), Avoid iterator creation when invoking statement interceptors in MysqlIO. + Thanks to Andrej Golovnin for his contribution. + + - Fix for Bug#70944 (17831255), community and commercial builds should have the same line number tables + + - Fix for Bug#71861 (18327245), Avoid manual array copy in MysqlIO and LoadBalancingConnectionProxy. + Thanks to Andrej Golovnin for his contribution. + + - Fix for Bug#71623 (18228668), Field#getStringFromBytes() creates useless byte array when using JVM converter. + Thanks to Andrej Golovnin for his contribution. + + - Fix for Bug#71621 (18228302), MysqlXAConnection#xidToString(Xid xid) produces too much garbage. + Thanks to Andrej Golovnin for his contribution. + + - Fix for Bug#67318 (16722637), SQLException thrown on already closed ResultSet. Thanks to Thomas Manville and Andrej Golovnin for their contribution. + + - Fix for Bug#71396 (18110320), setMaxRows (SQL_SELECT_LIMIT) from one query used in later queries (sometimes). + Additionally, SQL_SELECT_LIMIT is no longer sent unnecessarily between consecutive queries. + + - Fix for Bug#71432 (18107621), Key store files not closed when making SSL connection + + - Reserved words lists updated from latest official SQL:92 and SQL:2003 specifications. + + - Fix for Bug#18091639, STRINGINDEXOUTOFBOUNDSEXCEPTION IN PREPAREDSTATEMENT.SETTIMESTAMP WITH 5.6.15 + + - Added Fabric support + +02-10-14 - Version 5.1.29 + + - Fix for Bug#70701 (17647584), DatabaseMetaData.getSQLKeywords() doesn't match MySQL 5.6 reserved words. + + - Fix for Bug#17435879, REMOVE SRC/LIB-NODIST DIRECTORY FROM LAUNCHPAD DISTRIBUTION. + Additional "com.mysql.jdbc.extra.libs" parameter must be used for ant build. + + - Fix for Bug#71038, Add an option for custom collations detection. + Added new connection property detectCustomCollations=[true|false], with default false. + Please be aware that these changed the previous default behavior and if you use custom charsets or collations + you need to set detectCustomCollations=true. + + - Added tests for new index renaming syntax introduced in 5.7.1. + +12-23-13 - Version 5.1.28 + + - Fix for Bug#69579, DriverManager.setLoginTimeout not honored. + + - Fix for Bug#51313, Escape processing is confused by multiple backslashes. + + - Fix for Bug#55340, initializeResultsMetadataFromCache fails on second call to stored proc. + + - Fix for Bug#70969, Shadow declaration of OperationNotSupportedException in RowDataDynamic. + + - Fix for Bug#70835 (17750877), SQLExceptions thrown because of query interruption (KILL QUERY, query timeout, etc.) + didn't extend java.sql.SQLNonTransientException for JDBC4+ deployments. + + - Fix for Bug#24344 test case, test fails if it's run with UTC timezone settings. + + - Fix for Bug#69777, Setting maxAllowedPacket below 8203 makes blobSendChunkSize negative. + + - Fix for Bug#35115, yearIsDateType=false has no effect on result's column type and class. + + - Fix for Bug#68916 (16691047), closeOnCompletion doesn't work. + + - Fix for Bug #69746 (17164058), ResultSet closed after Statement.close() when dontTrackOpenResources=true + + - Fix for Bug#70842 (17753369), Adding live management of replication host topographies. + +11-04-13 - Version 5.1.27 + + - Fix for Bug#17248345, getFunctionColumns() method returns columns of procedure. + + - Fix for Bug#69290 (16879239), JDBC Table type "SYSTEM TABLE" is used inconsistently. + + - Fix for Bug#68562, Combination rewriteBatchedStatements and useAffectedRows not working as expected. + + - Fix for Bug#69452 (17015673), memory size connection property doesn't support large values well. + + - Added tests for InnoDB full-text search support introduced in 5.6GA. + + - Extended slow query warning with query execution plan for INSERT, REPLACE, UPDATE and DELETE. + + - Added tests for IPv6 functions introduced in 5.6GA. + + - Added support of authentication data up to 2^64-1 bytes. + + - Fix for Bug#38252, ResultSet.absolute(0) is not behaving according to JDBC specification. + + - Fix for Bug#62469, JDBC Authentication Fails with Null Byte in Scramble + + - Fix for Bug#69506, XAER_DUPID error code is not returned when a duplicate XID is offered in Java. + + - Added support for multi-master replication topographies in ReplicationDriver. ReplicationDriver now uses two discrete load-balanced + connections, one each for master and slave connections. The same load-balancing options which apply to load-balanced connections + now also apply to ReplicationConnections. By default, this means that when a ReplicationConnection uses master connections + (because the read-only property of the Connection is false), work may be re-balanced between configured master hosts at transaction + boundaries. As with load-balanced connections, the ReplicationConnection host list may be managed within the JVM (see + com.mysql.jdbc.ReplicationConnectionGroupManager) or optionally via JMX (using replicationEnableJMX configuration option; see + com.mysql.jdbc.jmx.ReplicationGroupManagerMBean). To specify multi-master replication topographies, define each host "type" + property using the following format: + + address=(host=hostname)(port=3306)(type=[master|slave]) + + In the absense of explicit type definitions, the driver will assume a single master listed first, with all subsequently-listed + hosts configured as slaves. + + - Fix for Bug#63354 (16443992), JDBC cannot make new connections if master is down. + + - Fix for Bug#17003626, REGRESSION TEST FAILURE WITH SERVER VERSION 5.7.1 + + - Removed ant-contrib.jar from C/J distribution. + + - Added tests for GIS precise spatial operations introduced in 5.6GA. + + - Fixed META-INF information + + - Fix for Bug#17251955, ARRAYINDEXOUTOFBOUNDSEXCEPTION ON LONG MULTI-BYTE DB/USER NAMES + + - Fix for Bug#50538, DatabaseMetaData.getDriverVersion() contains unexpanded ${bzr.revision-id} + +08-05-13 - Version 5.1.26 + + - Fix for Bug#69298 (16845965), Methods DatabaseMetaData.getProcedures() and DatabaseMetaData.getProcedureColumns(), in JDBC4, + return stored procedure only or both stored procedures and functions metadata information, depending on the value set in the + connection property "getProceduresReturnsFunctions", having default value 'true'. Several fixes in Functions and + Procedures metadata so that consulting I__S and MySQL/DDL returns the same info. + + - Fix for Bug#69308 (16879267), Avoid calling batchedStatement.close() twice, and thus raising and ignoring an undercover SQLException, in methods + PreparedStatement.executeBatchedInserts and PreparedStatement.executePreparedBatchAsMultiStatement. + + - Fix for Bug#68400, useCompression=true and connect to server, zip native method cause out of memory. + CompressedInputStream now does not keep reference to connection. + Thank Dominic Tootell for his investigation, proposed solution and all the help he provided. + + - Fix for Bug#65871, DatabaseMetaData.getColumns() throws an MySQLSyntaxErrorException. + Delimited names of databases and tables are handled correctly now. The edge case is ANSI quoted + identifiers with leading and trailing "`" symbols, for example CREATE DATABASE "`dbname`". Methods + like DatabaseMetaData.getColumns() allow parameters passed both in unquoted and quoted form, + quoted form is not JDBC-compliant but used by third party tools. So when you pass the indentifier + "`dbname`" in unquoted form (`dbname`) driver handles it as quoted by "`" symbol. To handle such + identifiers correctly a new behavior was added to pedantic mode (connection property pedantic=true), + now if it set to true methods like DatabaseMetaData.getColumns() treat all parameters as unquoted. + + - Fix for Bug#45757 (11754192), Don't allow updateRow() to be called when updatable cursor is positioned on insert row. + + - Fix for Bug#68098 (16224299), Return indexes sorted by NON_UNIQUE, TYPE, INDEX_NAME, and ORDINAL_POSITION in DatabaseMetaData.getIndexInfo. + + - Fix for Bug#68307 (16707803), Return correct COLUMN_TYPE from both getProcedureColumns() and getFunctionColumns(). + + - Fix for Bug#42267, PreparedStatementWrapper doesn't have a toString() implementation + + - Fix for Bug#44451 (11753081), Added missing fields in methods getColumns(), getProcedureColumns(), getTables() and getUDTs(). + Methods getClientInfoProperties() and getFunctions() were made available in all *DatabaseMetaDataUsingInfoSchema implementations. + +05-06-13 - Version 5.1.25 + + - Fix for Bug#68801, java webstart mysql-connector-java lib calls -bin library. + + - Fix for Bug#16426462, SyntaxRegressionTest failing on C/J 5.1.24 against MySQL 5.6.10 + + - Fix for Bug#60816, Cannot pass NULL to an INOUT procedure parameter. + + - Added support for Connection Attributes when used with MySQL Server versions (5.6+) which support this feature. + By default, the following standard attributes are sent to the server, where they can be seen in the + performance_schema.session_connect_attrs table: + * _client_version : the version of MySQL Connector Java in use + * _client_name : "MySQL Connector Java" + * _runtime_version : the version of the Java runtime environment in which the driver is running + * _runtime_vendor : the name of company which produced the Java runtime environment + Additionally, users may supply their own key/value attributes to be exposed by providing them in + "key1:value1,key2:value2" format in the connectionAttributes connection property. + To avoid sending any connection attributes to the server, set connectionAttributes property to "none". + + - Fix for Bug#68763 (16545334), ReplicationConnection.isMasterConnection() returns false always. + + - Fix for Bug#68733 (16526938), ReplicationConnection doesn't ping all slaves. + + - Fix for Bug#68556, Tomcat can't stop a cleanup thread by clearReferencesStopThreads. + + - Fix for Bug#16436511, getDriverName() returns a string with company name "MySQL-AB". Driver name changed to "MySQL Connector Java". + + - Fix for Bug#68664 (16486957), Enable packaging of .JAR file from Eclipse. + +03-05-13 - Version 5.1.24 + + - Fix for Bug#64204, ResultSet.close hangs if streaming query is killed. + + - Fix for Bug#16224249, Deadlock on concurrently used LoadBalancedMySQLConnection: + 1) abortInternal() method was moved from com.mysql.jdbc.MySQLConnection to com.mysql.jdbc.Connection interface; + 2) load-balanced/failover proxy now broadcasts abortInternal() to all underlying physical connections; + 3) load-balanced/failover proxy now prevents picking of new physical connection after close() or abortInternal() were called explicitly on proxy; + 4) connection synchronization mutex was refactored, now mutex is proxy instance for proxied connection or connection instance itself if there is no proxy. + + - Fix for Bug#64805, StatementImpl$CancelTask occasionally throws NullPointerExceptions. + + - Fixed typos in descriptions of properties. + + - Fix for Bug#68011, Invalid error message noDatetimeSync property instead of noDatetimeStringSync. + +02-04-13 - Version 5.1.23 + + - Fix for Bug#35653, executeQuery() in Statement.java let "TRUNCATE" queries being executed. "TRUNCATE" and "RENAME" are now filtered for executeQuery(). + + - Fix for Bug#65909, referenceThread causes memory leak in Tomcat. + Abandoned connection cleanup thread was refactored to have static shutdown method. + If you encountered this leak problem, your application should implement context listener with + AbandonedConnectionCleanupThread.shutdown() call in contextDestroyed method. + + For example: + @WebListener + public class YourThreadsListener implements ServletContextListener { + public void contextDestroyed(ServletContextEvent arg0) { + try { + AbandonedConnectionCleanupThread.shutdown(); + } catch (InterruptedException e) { + } + } + ... + } + + Note that if container does not support annotations you should add description to web.xml: + + user.package.YourThreadsListener + + + - Added tests for explicit partition selection syntax introduced in 5.6GA. + + - Added support of password expiration protocol. This introduces new boolean connection property disconnectOnExpiredPasswords. + If disconnectOnExpiredPasswords = true and password expired then connection will be rejected by server with ErrorCode == 1820 (ER_MUST_CHANGE_PASSWORD). + If disconnectOnExpiredPasswords = false then connection will enter to "sandbox" mode, + all commands except SET PASSWORD = ... and SET PASSWORD FOR CURRRENT_USER() = ... will cause an error to be thrown. + + - Added tests for EXCHANGE PARTITION syntax introduced in 5.6GA. + + - Added tests for transportable tablespaces syntax introduced in 5.6GA. + + - Added tests for CREATE TABLE syntax changed in 5.6GA: CREATE TABLE ... DATA DIRECTORY = 'absolute/path/to/directory/' + + - Added tests for ALTER TABLE syntax changed in 5.6GA: ALGORITHM and LOCK keywords. + + - Fix for Bug#67954, stack trace used for point-of-origin in log and exception messages + causes permgen leak with webapp classloader on application redeploy. We no longer store the entire + stack trace, only the calling class and method, and even then, that only when using the usage advisor + or when profiling. + + - Fix for Bug#11237, useCompression=true and LOAD DATA LOCAL INFILE SQL Command. + + - Static charset/collation maps were updated. + + - Fix for Bug#14260352, difference in Timestamp value returned with rewriteBatchedStatements=true. + + - Fix for Bug#60598, nativeSQL() truncates fractional seconds. + + - Fix for Bug#40279, Timestamp values get truncated when passed as prepared statement parameters. + This was partly fixed in 5.1.19 but that fix did not cover useLegacyDatetimeCode=true case. + + - Fix for Bug#14665141, Diff results returned from ResultSet and CachedRowSet with new password hashing. + Test suite modified to don't perform comparison of PASSWORD() results if old_passwords=2 + because with SHA-256 password hashing enabled they are nondeterministic. + + - The driver now allows the mechanism for caching MySQL server configuration values replaceable at runtime, + via the "serverConfigCacheFactory" property. The default is an implementation that is a per-VM concurrent + map, keyed by URL. The driver will invalidate cache entries when SQLExceptions that indicate communications + errors are thrown (on the assumption that the server has been or is restarting), or if the server version + that is being connected to, differs from the one that was present when the cached values were populated. + + To replace the default implementation, implement CacheAdapterFactory>, and + use the fully-qualified class name of this implementation for "serverConfigCacheFactory". + + - Connection.setReadOnly() will take advantage of server-side support for read-only transactions + present in MySQL-5.6 and newer. Calling .isReadOnly() will incur a round-trip if useLocalSessionState + is not enabled. + +09-06-12 - Version 5.1.22 + - Fix for Bug#57662, Incorrect Query Duration When useNanosForElapsedTime Enabled. + + - Fix for Bug#65503, ResultSets created by PreparedStatement.getGeneratedKeys() are not close()d. + + - Fix for Bug#63800, getVersionColumns() does not return timestamp fields; always empty. + Added support of ON UPDATE CURRENT_TIMESTAMP for TIMESTAMP and DATETIME fields. + + - Fix for Bug#41752, Can't connect mysqld which character_set_server=ucs2. + + - Fix for Bug#65508, getCharsetNameForIndex() should be faster. + + - Fix for Bug#14563127, Load-balanced connection fails to select valid host, closes connection + on re-balance. + +07-05-12 - Version 5.1.21 + - Added new built-in authentication plugin com.mysql.jdbc.authentication.Sha256PasswordPlugin + ("sha256_password"). + + - Fix for Bug#64731, StringUtils.getBytesWrapped throws StringIndexOutOfBoundsException. + + - Added new built-in authentication plugin com.mysql.jdbc.authentication.MysqlClearPasswordPlugin + ("mysql_clear_password"). It allows C/J based clients to connect to MySQL accounts which use + PAM authentication for example. SSL connection required for this authentication method. + If SSL is not enabled then authentication which requires "mysql_clear_password" will lead to an error. + + - Fix for Bug#13980303, Auth plugin's confidentiality requirements are not checked after Auth Switch Request. + + - Fix for Bug#64205, Connected through Connector/J 5.1 to MySQL 5.5, the error message is garbled. + + - Fix for Bug#37931, Null Pointer Exception Thrown When specifying invalid character_set_results enc. + + - Fix for Bug#36662, TimeUtil.java: MEST mapping n/a. + + - Fix a scalability/memory footprint issue where Object.finalize() was being used on + ConnectionImpl to clean up the low-level network connection to MySQL should a + connection be abandoned by the application before being cleanly close()d. We now + track connections in a phantom reference queue, and have a single thread per-vm + clean these up when the VM notices the connection is no longer referenced by + anything else. + + - Added the ability to add new client-side prepared statement parse info caches by + implementing com.mysql.jdbc.CacheAdapterFactory and telling the driver to use it + when "cachePrepStmts=true" via the "parseInfoCacheFactory" configuration property. + + - Implemented JDBC-4.1 methods from Java-7: + + - Connection.setSchema(String) - no-op, until we support database==schema in the driver + - Connection.getSchema() - see above + - Connection.abort(Executor executor) + - Connection.setNetworkTimeout(Executor, int) + - Connection.getNetworkTimeout() throws SQLException; + - CallableStatement.getObject(int, Class) + - CallableStatement.getObject(String, Class) + - DBMD.getPseudoColumns() - returns an empty result set + - DBMD.generatedKeyAlwaysReturned() - always true for MySQL + - ResultSet.getObject(int, Class) + - ResultSet.getObject(String, Class) + - Statement.closeOnCompletion() + - Statement.isCloseOnCompletion() + +05-02-12 - Version 5.1.20 + - Fix for Bug#64983, 5.1.19 not working with JBoss AS 4.2.3.GA. + + - Fix for Bug#13960556, java.lang.StringIndexOutOfBoundsException in com.mysql.jdbc.PreparedStatement.formatNanos(int nanos). + + - Fix for pluggable authentication tests to run on Windows. + + - Fix for Bug#13897714, NPE in testsuite.regression.StatementRegressionTest.testBug1933() with 5.6.5_m8 server. + + - Fix for Bug#55962, Savepoint identifier is occasionally considered as floating point numbers. + + - Fix for Bug#13955027, SET OPTION syntax was removed starting from 5.6.5 server version. + + - Fix for Bug#13958793, ClassCastException in ConnectionImpl.buildCollationMapping() with 4.1 server. + + - Fix for Bug#36478, Client prepared statement bugged if word 'limit' included in the query. + +04-02-12 - Version 5.1.19 + - Fix for Bug#64621, setMaxRows was not correctly processed during CS PS metadata + collection causing entire resultset to be fetched and possibly leading to OOM. + + - Fix for Bug#63456, MetaData precision is different when using UTF8 or Latin1 tables. + The problem was in finding maxBytesPerChar through versioned mapping from Java charset to MySQL charset. + That map returns "utf8mb4" instead "utf8" for server versions starting with 5.5.2. + CharsetMapping, ConnectionImpl and Field have been reorganized to use static maps INDEX_TO_MYSQL_CHARSET, + STATIC_CHARSET_TO_NUM_BYTES_MAP instead. Also dynamic maps ConnectionImpl.indexToCustomMysqlCharset + and ConnectionImpl.mysqlCharsetToCustomMblen have been added for custom charsets. + + - Added support for pluggable authentication via the com.mysql.jdbc.AuthenticationPlugin + interface (which extends standard "extension" interface). Examples are in + com/mysql/jdbc/authentication and in testsuite.regression.ConnectionRegressionTest. + This introduces three new properties: + + authenticationPlugins defines comma-delimited list of classes that implement + com.mysql.jdbc.AuthenticationPlugin and which will be used for authentication + unless disabled by "disabledAuthenticationPlugins" property. + + disabledAuthenticationPlugins defines comma-delimited list of classes implementing + com.mysql.jdbc.AuthenticationPlugin or mechanisms, i.e. "mysql_native_password". + The authentication plugins or mechanisms listed will not be used for authentication + which will fail if it requires one of them. It is an error to disable the default + authentication plugin (either the one named by "defaultAuthenticationPlugin" property + or the hard-coded one if "defaultAuthenticationPlugin" propery is not set). + + defaultAuthenticationPlugin defines name of a class implementing + com.mysql.jdbc.AuthenticationPlugin which will be used as the default authentication + plugin. It is an error to use a class which is not listed in "authenticationPlugins" + nor it is one of the built-in plugins. It is an error to set as default a plugin + which was disabled with "disabledAuthenticationPlugins" property. It is an error + to set this value to null or the empty string (i.e. there must be at least a valid + default authentication plugin specified for the connection, meeting all constraints + listed above). + + - Fix for Bug#63526. The problem happens in com.mysql.jdbc.EscapeProcessor#escapeSQL. The function recognizes the string in the create table statement as an escape sequence (line 136+138). The "if" construct beginning in line 182 tries to match a white-space collapsed version of the string to prefixes for valid jdbc-escapes (till line 300). Since no matching escape sequence is found and no "else" clause is defined, neither the token, nor replacement are added to the resulting escaped SQL string. + + - Fix for Bug#61203, noAccessToProcedureBodies does not work anymore. + + - Fix for Bug#63811, pointless Socket.bind() when using ephemeral ports and interfaces, which limits scalability on some platforms. + + - Connection.changeUser() would not check for closed connections, leading to NPEs when this method was called on a closed connection. + + - Fix for Bug#63284, memory leak with Failover proxied Statement/PreparedStatement with DBCP due to improper implementation of equals(). + + - Prepared statements would needlessly allocate a 4K buffer for converting + streams when no set*Stream() methods had been used. + +10-03-11 - Version 5.1.18 + + - Fix for Bug#12565726, not putting the space between VALUES() and ON DUPLICATE KEY UPDATE + causes C/J a) enter rewriting the query although it has ON UPDATE + and b) to generate the wrong query with multiple ON DUPLICATE KEY + + - Fix for Bug#12784170, "process fork failure" errors while running test suite via ant on Windows. + Added new ant flag, com.mysql.jdbc.junit.fork, which controls whether JUnit will fork new processes + for testing ("on", default and legacy behavior) or not ("off", required for Windows). + + - Reverting changes made to ConnectionImpl.java, + private boolean characterSetNamesMatches function. + + - Added function MYSQL_INDEX_TO_MYSQL_CHARSET to retrieve server charset name + using index instead of parsing variables to CharsetMapping.java. + + - Completed fix for Bug#61201/12649557, fixed tests failures. + + - Fix for Bug#61201/12649557, Can't establish connection when url has + sessionVariables and characterEncoding. Fix covers only MySQL server 4.1+ + + - Fix for Bug#61501 - Calling Statement.cancel() on a statement that isn't + currently executing will cause some later-executed query on the same + connection to be cancelled unexpectedly. The driver now guards against this + condition, but it is an underlying server issue. The MySQL statement "KILL QUERY" + (which is what the driver uses to implement Statement.cancel()) is rather + non-deterministic, and thus the use of Statement.cancel() should be avoided + if possible. + + - Fix for Bug#61866/12791594 - Calling Statement.getWarnings() after + Statement.clearWarnings() has been called, returns the "old" warnings. + + - Fix for Bug#13036537 - LRUCache was really a least-recently-added cache. + + - Fix for Bug#13036309, Correcting parameter name in maxPerformance.properties. + + +07-04-11 - Version 5.1.17 + + - Fix for Bug#61332 - LIKE not optimized in server when run against I__S tables and no wildcards used. + Databases/tables with "_" and/or "%" in their names (escaped or not) will be handled by this code path, + although slower, since it's rare to find these characters in table names in SQL. If there's a "_" or "%" + in the string, LIKE will take care of that, otherwise we now use = . The only exception is + information_schema database which is handled separately. Patch covers both getTables() and getColumns(). + + - Fix for Bug#61150 - First call to stored procedure fails with "No Database Selected". + The workaround introduced in DatabaseMetaData.getCallStmtParameterTypes to fix + the bug in server where SHOW CREATE PROCEDURE was not respecting lower-case table names + is misbehaving when connection is not attached to database and on non-casesensitive OS. + + - Fix for Bug#61105 - Avoid a concurrent bottleneck in Java's character set + encoding/decoding when converting bytes to/from Strings. + +04-21-11 - Version 5.1.16 + + - Partial fix for BUG#54135 - setQueryTimeout unsafe across VIP. Fix prevents c/J from + killing the right ConnectionID but on wrong server. + + - Fix for BUG#57808 - wasNull not set for DATE field with value 0000-00-00 + in getDate() although zeroDateTimeBehavior is convertToNull. + + - Fix for Bug#54425 - Bypassing the server protocol bug where DB should be null-terminated + whether it exists or not. Affects COM_CHANGE_USER. + + - Fix for Bug#60313 (11890729), bug in + com.mysql.jdbc.ResultSetRow.getTimestampFast(). + + - Fix for bug 11782297, DBMD.getTables (so thus getColumns too) fails with + table names containing dot (like "junk_[Sp:e,c/ C-h+a=.r]"). + + - Added the ability to determine if the connection is against a server on the + same host via the Connection.isServerLocal() method. + + - Fix for bug 12325877, Setting "autoReconnect=true" and + "cacheServerConfiguration=true" would cause connections created after + an existing connection fails to have non-existent values for server + variables which lead to exceeding of max allowed packet exceptions when the + new connections were used. + +02-08-11 - Version 5.1.15 + + - Fix for Bug#38367, parameters metadata did not reflect the fact that NULL is allowed + parameter value. So DatabaseMetaData.getProcedureColumns will set isNullable member to + java.sql.DatabaseMetaData.procedureNullable now. + + - Completed fix for Bug#27916. + + - Fix for Bug#59224, adding 5.5 reserved words to DatabaseMetaData.getSQLKeywords(). + + - Fixed an issue where statement comments set via Connection.setStatementComment() + weren't represented in autoGenerateTestcaseScript=true output. + + - Added ability to include the current java thread dump in the exception message + given for deadlock/wait lock timeout exceptions, enable with + "includeThreadDumpInDeadlockExceptions=true" in your JDBC url. + + - Added ability to include current thread name as a statement comment visible + in MySQL's "SHOW PROCESSLIST" and Innodb deadlock diagnostics, enable with + "includeThreadNamesAsStatementComment=true". + + - Added an SLF4J logging adapter. Enable by adding setting the connection + property "logger" to "Slf4JLogger" and placing the appropriate bridge + from SLF4J to the logging framework of choice in your CLASSPATH. As with + other Connector/J logging adapters, the log category name used by the + driver is "MySQL". See http://www.slf4j.org/manual.html for more details. + +12-06-10 - Version 5.1.14 + + - Fix for Bug#58728, NPE in com.mysql.jdbc.jdbc2.optional.StatementWrappe.getResultSet() + if rs is null. Regression test case added to Statement regression tests. + + - Fix for Bug#58751, DatabaseMetadata.getIndexInfo() CARDINALITY now clamped + to Integer.MAX_VALUE. + + - Fix for BUG#58590 + - Testsuite.Simple.DateTest, MetadataTest, NumbersTest and StatementsTest cleaned and fixed. + + - Testsuite.simple, ConenctionTest & DataSourceTest are up to date. Major rework on + ConnectionTest.testDeadlockDetection (Sveta) and testUseCompress. + + - Testsuite.simple, CallableStatementTest & CharsetTests are up to date. + + - Testsuite.regression SubqueriesRegressionTest and StringRegressionTest are up to date. + + - Testsuite.regression MicroPerformanceRegressionTest, NumbersRegressionTest, PooledConnectionRegressionTest, + ResultSetRegressionTest are up to date. + + - Testsuite.regression.MetaDataRegressionTest up to date. + + - Typo in StatementRegressionTest.testLikeWithBackslashes fixed. StatementRegressionTest + is up to date. + + - Fix for Bug#58232 - CallableStatement fails to fetch OUT parameter against 5.5 server + + - Testsuite.regression.Connection, tests for BUG#45419 refined by Todd so not to cause failures. + + - Testsuite.regression.CallableStatement, tests for BUG#26959 failing against 5.5+ server. + + - Bringing testsuite.regression.CachedRowsetTest up to date. + + - Bringing BLOBregression tests up to date. + + - Fix for Bug#58042 - Statements test failure not handled. + + - Fix for Bug#57850 - Refresh SELECT statement doesn't use correct data type. + Added Field.valueNeedsQuoting (private final boolean) and protected boolean getvalueNeedsQuoting(). + UpdatableResultSet refresher and updater call upon this value now. + + - Removing commented source in fix for Bug#57697 + - Fix for Bug#57697 - Metadata getTables() was not checking for table_name already been quoted. + - Fix for Bug#57694 - 3byte UTF8 can not be used with 5.5.3+ server. + - Fix for Bug#57701 - StatementsTest.testBatchRewriteErrors() failing on new servers. + + - Fix for Bug#54756 - Cannot retrieve data from ResultSet by column name from a Sphinx daemon. + We were relying only on "server version string" passed. Now, determining + server version is done via protocol flags too, where applicable. + + - Fix for Bug#57022 - cannot execute a store procedure with output parameters, + database parameter was ignored in db.sp notation. The fix is to "sanitize" + db.sp call just like in patch for noAccessToProcedureBodies. BaseTestCase + extended with createDatabase and dropDatabase. Regression test added. + + - Fix for Bug#57262 - "useOldUTF8Behavior" behavior was broken since 5.1.3, + now explicitly sets connection character set to latin1 ("SET NAMES latin1") + during connection post-handshake process. + + - Patch for problem where "noAccessToProcedureBodies=true" was causing + "underprivileged" user not to have access to procedures created by him. + + - Patch for Bug#56305, unhandled NPE in DatabaseMetaData.java when calling + wrong-cased function without access to mysql.proc. Although simple by + itself, some more enhancements were needed for everything to function + properly. So, along with catching potential NPE due to server bug, a + guard against calling JDBC functions with db_name.proc_name notation was + also added. Necessary changes added to StringUtils.java too. + + - Added ability to load-balance while auto-commit is enabled. This + introduces two new properties: + + loadBalanceAutoCommitStatementThreshold defines the number of matching + statements which will trigger the driver to (potentially) swap physical + server connections, + + loadBalanceAutoCommitStatementRegex defines the regular expression + against which statements must match. The default values (0 and blank, + respectively) retain the previously-established behavior that + connections with auto-commit enabled are never balanced. Feature + request documented in Bug#55723. + + - Minor fix in getProcedureColumns() DisplaySize for Bug#51712. Fix for + Bug#41269 is not complete without this. getColumnDisplaySize on a + ResultSet already consisting of metadata is now functional thanks to + Bogdan. + + - Minor fix for Bug#55217, return 4 as a result of DataBaseMetadata.getJDBCMajorVersion() as per manual. + + - Added support for hosts specified in the URL of the form: + address=(key=value), supported keys are: + + (protocol=tcp or pipe (for named pipes on Windows) + (path=[] for named pipes) + (host=[]) for TCP connections + (port=[]) for TCP connections + + An example would be: + + jdbc:mysql://address=(protocol=tcp)(host=localhost)(port=3306)(user=test)/db + + Any other parameters are treated as host-specific properties that follow + the conventions of the JDBC URL properties. This now allows per-host + overrides of any configuration property for multi-host connections + (failover, loadbalance, replication). We do recommend that the overrides + are limited to user, password, network timeouts and statement and + metadata cache sizes. Unexpected behavior may be observed with other + per-host overrides. + + - Fix for Bug#56099 - Added support for JDBC4-specific functionality when + using load-balanced connections. + + - Fix for Bug#56200 - Added diagnostic information to SQLException message + thrown when a closed load-balanced connection is reused. This + information will identify the conditions which caused the connection to + be closed. + + - Fix for Bug#56429 - When using Connector/J configured for failover + (jdbc:mysql://host1,host2,... URLs), the non-primary servers re-balance + and spawned new idle connections when the transactions on the master were + committed or rolled-back, eventually exceeding max_connections. It was + also discovered that session state (autocommit, isolation level, catalog) + wasn't being copied from the primary connection to secondary + connections correctly because of the same changes that caused this bug, + and this was fixed as well. + + - Fix for Bug#56706 - Ensure read-only state is synchronized when new + load-balanced connections are selected. + + - Fixed Bug#56955 - Connection properties "trustCertificateKeyStoreType" + and "clientCertificateKeyStoreType" have invalid defaults, therefore + connections that specify "useSSL" will sometimes fail with exceptions + from JSSE unless "JKS" has been specified for both of these properties. + The default value for these properties is now "JKS", and thus it no + longer has to be specified. + + - Fixed Bug#56979 - Improper connection closing logic leads to TIME_WAIT + sockets on server + + - Fixed Bug#57380 - DatabaseMetaData.supportsMultipleResultSets() now returns + true when connected to a 4.1 version or later server. + + - Fixed Bug#58706 - Failover connections didn't honor "failOverReadOnly=false", and in some + situations would not fall back. + + - Removed logging integrations with log4j and apache-commons-logging due to license + incompatibility. Replacing with SLF4J integration in next release. + +06-24-10 - Version 5.1.13 + + - Minor fix in previous patch for Bug#51904. Function ConnectionImpl.setCatalog() was passed quoted argument thus breaking with "...for the right syntax to use near 'test``'" + + - Fix for Bug#51912 - Passing NULL as cat. param to getProcedureColumns with !nullCatalogMeansCurrent + + - Fix for Bug#52167 - Can't parse parameter list with special characters inside + + - Fix for Bug#51904 - getProcedureColumns() always returns PROCEDURE_CAT result column as NULL + + - Fix for Bug#51712 - Display Size is always 0 for columns returned by getProcedureColumns() + + - Fix for Bug#51908 - db variable might have end up unassigned when calling + getProcedureColumns()/Functions(). This is a followup on code changes made + for Bug#51022. + + - Fixed Bug#51266 - jdbc:mysql:loadbalance:// would stick to the first + host in the list in some cases, especially exacerbated if the host was + down. + + - Replaced URLs of the form jdbc:mysql://host-1,host-2 with a composite of + a normal connection and a jdbc:mysql:loadbalance:// connection for more + robustness and cleaner code. + + - Fixed BUG#51643 - Connections using jdbc:mysql:loadbalance:// would + have statements (and prepared statements) that did not have their connections + changed upon commit()/rollback(), and thus applications that held statement + instances past commit()/rollback() could have data written to or read from + un-intended connections. + + - Fixed BUG#51666 - StatementInterceptors were never "un-safed" after connection + establishment, causing interceptors which returned result sets pre/post execution + would not work. + + - Fixed BUG#51783 - Load-balanced connections could throw a SQLException + incorrectly on commit() or rollback(). This was not caused by failures in commit + or rollback, but rather by the possibility that the newly-selected physical + connection was stale. Added logic to catch and retry if this happens, up to + the number of hosts specified for load-balancing. Also added new property, + loadBalanceValidateConnectionOnSwapServer, which controls whether to explicitly + ping the selected host (otherwise, the host is presumed to be up, and will only + be noticed if auto-commit or transaction isolation state needs to be set and + fails). + + - Added loadBalancePingTimeout property to allow a specific timeout to be set + for each ping executed against the servers. This ping is executed when the + physical connections are rebalanced (commit/rollback or communication exception), + or when a query starting with (exactly) "/* ping */" is executed. The latter + causes each open underlying physical connection to be pinged. + + - Fixed BUG#51776 - Connection.rollback() could swallow exceptions incorrectly. + + - Fixed BUG#52231 - Differences in definitions of which SQLExceptions trigger + a failover event could result in failure to try more than a single host in + certain situations. + + - Fixed BUG#52534 - Performance regression using load-balanced connection. + + - More aggressively purge the statement timeout timers after they've been cancelled to + trade time for memory. This purge only happens if statement timeouts are in use. + + - Added management of running load-balanced connections. Statistics can be obtained, + and hosts added/dropped via com.mysql.jdbc.ConnectionGroupManager or the JMX + implementation. This functionality is enabled by setting the new paramenter, + loadBalanceConnectionGroup to the name of the logical grouping of connections. + All load-balanced connections sharing the same loadBalanceConnectionGroup value, + regardless of how the application creates them, will be managed together. To + enable JMX-based management, set loadBalanceEnableJMX=true and ensure that remote + JMX is enabled in the JRE (eg, use -Dcom.sun.management.jmxremote). + + - Added loadBalanceExceptionChecker property, which takes a fully-qualified class + name implementing com.mysql.jdbc.LoadBalancedExceptionChecker interface. This + allows custom evaluation of SQLExceptions thrown to determine whether they should + trigger failover to an alternate host in load-balanced deployments. The default + is com.mysql.jdbc.StandardLoadBalanceExceptionChecker. + + - Added two new properties which allow more flexibility in determining which + SQLExceptions should trigger failover in a load-balanced deployment. The new + loadBalanceSQLStateFailover property takes a comma-delimited list of SQLState + codes which are compared to the SQLState of the SQLException (matching done + with trailing wildcard), while loadBalanceSQLExceptionSubclassFailover takes + a comma-delimited list of fully-qualified class/interface names, against + which the SQLException is checked to determine if it is an instance of any. + Matches trigger failover to an alternate host. + + - Fixed Bug#51704 - Re-written batched statements don't honor escape processing + flag of their creator. + + - Fixed Bug#43576 - Sometimes not able to register OUT parameters for + CallableStatements. + + - Fixed Bug#54175 - Driver doesn't support utf8mb4 for servers 5.5.2 and newer. The + driver now auto-detects servers configured with character_set_server=utf8mb4 or + treats the Java encoding "utf-8" passed via "characterEncoding=..." as utf8mb4 in + the "SET NAMES=" calls it makes when establishing the connection. + +02-18-10 - Version 5.1.12 + + - NO_INDEX_USED and NO_GOOD_INDEX used were only being set when profileSQL + was set to "true", and in some cases their values were reversed. + + - Fix for Bug#51022 - conn.getMetaData().getProcedures("schema",null,"%"); + returns all stored procedures from all databases and not only for given + one. + + - Fixed Bug#50538 - ${svn.revno} shows up in DBMD.getDriverVersion(). + + - Removed usage of timestamp nanoseconds in PreparedStatement.setTimestamp(), + as long as Bug#50774 exists in the server and there's no real support + for nanos/micros in TIMESTAMPs, avoid the performance regression usage of + them causes. + + +01-20-10 - Version 5.1.11 + + - Fix for BUG#50288 - NullPointerException possible during invalidateCurrentConnection() for load-balanced + connections. + + - Fix for BUG#49745 - deleteRow() for updatable result sets can cause full table scan because escaped hex + values are used for primary key identifiers. + + - Fix for BUG#49607 - Provide Connection context in ExceptionInterceptor. + + - Fix for BUG#48605 - Ping leaves closed connections in liveConnections, causing subsequent Exceptions when + that connection is used. + + - Fix for BUG#48442 - Load-balanced Connection object returns inconsistent results for hashCode() and equals() + dependent upon state of underlying connections. + + - Fix for BUG#48172 - Batch rewrite requires space immediately after "VALUES" + + - Statement Interceptors didn't completely intercept server-side prepared statements. + + - Fix for BUG#48486 Cannot use load balanced connections with MysqlConnectionPoolDataSource. + + - Fix for Bug#32525 - "noDatetimeStringSync" doesn't work for server-side prepared statements. Now it does. + + - Hooked up exception interceptors so they get called now. + + - Rev'd the statement interceptor interface to pass on some server flags, warning counts and errors. See + the com.mysql.jdbc.StatementInteceptorsV2 interface for more details. The driver will create adaptors to + transparently convert older implementations to the newer interface at runtime. + + - Statement Interceptors are now enabled at connection instantiation, but + can not return result sets (they will be ignored) until the connection + has bootstrapped itself. If during the init() method your interceptor + requires access to the connection itself, it should ensure that methods + that might throw exceptions if the connection is closed should handle + this in a robust manner. + + - "Replication" connections (those with URLs that start with + jdbc:mysql:replication) now use a jdbc:mysql:loadbalance connection + under the hood for the slave "pool". This also means that one can set + load balancing properties such as "loadBalanceBlacklistTimeout" and + "loadBalanceStrategy" to choose a mechanism for balancing the load and + failover/fault tolerance strategy for the slave pool. This work was done + in order to fix Bug#49537. + + - Fixed Bug#36565 - permgen leak from java.util.Timer. Unfortunately no great + fix exists that lets us keep the timer shared amongst connection instances, so + instead it's lazily created if need be per-instance, and torn down when the + connection is closed. + + - Fixed BUG#49700 - Connections from ConnectionPoolDataSource don't + maintain any values set with "sesssionVariables=...". This was a bug + in Connection.changeUser()/resetServerState(), we now resubmit the + session variables during the execution of these methods. + +09-22-09 - Version 5.1.10 + + - Fix for BUG#47494 - Non standard port numbers in the URL are not honored. + +09-16-09 - Version 5.1.9 + + - The driver has been OSGi-ified. The bundle symbolic name is "com.mysql.jdbc", see META-INF/MANIFEST.MF to see + what interfaces we export. + + - Fixed BUG#45040, adding missing tags from SVN import to BZR branch for + 5.1. + + - Fix for a variant of Bug#41484 - ResultSet.find*(String) failed when using cached result set + metadata. + + - Fixed BUG#46637 - When the driver encounters an error condition that causes it to create a + CommunicationsException, it tries to build a friendly error message that helps diagnose + what is wrong. However, if there has been no network packets received from the server, + the error message contains bogus information like: + + "The last packet successfully received from the server was 1,249,932,468,916 milliseconds ago. + The last packet sent successfully to the server was 0 milliseconds ago." + + Now the error message states that it has never received any packets from the server in this + scenario. + + - Added a new option, "queryTimeoutKillsConnection", when set to "true" will cause timeouts set + by Statement.setQueryTimeout() to forcibly kill the connection, not just the query. + + - Fixed BUG#32216, "PORT" property filled in by Driver.parseURL() not always present. The driver + will now always fill in the "PORT" (using 3306 if not specified) property, and the "HOST" property + (using "localhost" if not specified) when parseURL() is called. The driver also parses a list of hosts + into HOST.n and PORT.n properties as well as adding a property "NUM_HOSTS" for the number of hosts + it has found. If a list of hosts is passed to the driver, "HOST" and "PORT" will be set to the + values given by "HOST.1" and "PORT.1" respectively. This change has centralized and cleaned up a large + swath of code used to generate lists of hosts, both for load-balanced and fault tolerant connections and + their tests. + + - Fixed the ResultSet side of BUG#23584 - Calendar discared when retrieving dates from server-side prepared + statements. The other cases of this bug were fixed when "useLegacyDatetimeCode=false" became the default. + + - Fixed Bug#44324 - Data truncation exceptions did not return the vendor error code from the server. Note that + the vendor error code is not hard-coded to 1265 as in the bug report, because the server returns different + error codes for different types of truncations, and we did not want to mask those. + + - Fixed Bug#27431 - ResultSet.deleteRow() advances the cursor. The driver now places the cursor on the prior + row in the result set, or before the start of the result set if the result set is empty after the deletion. + + - Fixed Bug#43759 - ResultSet.deleteRow() generates corrupt DELETE statement for primary keys with binary + data. + + - Fixed Bug#46925 - Suspendable XA connections were not pinned to the XID for the global transaction, leading + to failure when attempting to suspend/resume/commit from different logical XA connections. + + - Fixed Bug#44508 - DatabaseMetadata.getSuperTypes() returns result set with incorrect column names. + + - Fixed Bug#46788 - Batched prepared statements with ON DUPLICATE KEY UPDATE are rewritten incorrectly when + when there are parameters as part of the UPDATE clause. Statements of this form can not be rewritten + as multi-value INSERTs so they are rewritten into multi-statements instead. + +07-16-09 - Version 5.1.8 + - Fixed BUG#44588 - Fixed error message for connection exceptions when + streaming result sets are used. + + - Modified/fixed test cases using UnreliableSocketFactory. + + - Fixed BUG#43421 - Made doPing() global blacklist-aware, so that it does not + throw Exceptions when at least a single load-balanced server is available. + + - Fixed BUG#43071 - Specifying ASCII encoding for converting seed String to + byte array; allowing system default encoding to be used causes auth failures + on EBCDIC platforms. + + - Fixed BUG#43070 - traceProtocol parameter isn't configured early enough to + capture handshake protocol. + + - Fixed BUG#41161 - PreparedStatement.addBatch() doesn't check for all parameters + being set, which leads to a NullPointerException when calling executeBatch() and + rewriting batched statements into multi-value or multi-statement statements. + + - Fixed BUG#42055 - ConcurrentModificationException possible when removing items + from global blacklist. + + - Fixed Bug #42309 - Statement.getGeneratedKeys() returns 2 keys when + using ON DUPLICATE KEY UPDATE + + - Fixed some quoting of substituted parameter issues in localized error messages. + + - Added a version check around getting the variable 'auto_increment_increment' for + servers < 5.0.2, which quiets down a warning message that the driver would log + when connecting to MySQL-4.1 or older. + + - The driver will automatically disable elideSetAutoCommit and useLocalTransactionState + if it detects a MySQL server version older than 6.0.10 with the query cache enabled, due + to Bug#36326 which can cause the server to report bogus transaction state. + + - Fixed a performance regression (Bug#41532) in rewritten batched inserts when "ON DUPLICATE KEY" + was present. + + Fixes include an improvement to token searching in the statement, and the ability for the driver + to rewrite prepared statements that include "ON DUPLICATE KEY UPDATE" into multi-valued inserts as + long as there is no use of LAST_INSERT_ID() in the update clause (as this would render + getGeneratedKey() values incorrect). + + - Fixed Bug#44056 - Statement.getGeneratedKeys() retains result set instances until statement is closed, + thus causing memory leaks for long-lived statements, or statements used in tight loops. + + - Fixed issues with server-side prepared statement batch re-writing caused by the fix to Bug#41532. + Rewriting of batched statements now works the same between normal prepared statements and server-side + prepared statements. + + - Fixed Bug#44862 - getBestRowIdentifier does not return resultset as per JDBC API specifications + + - Fixed Bug#44683 - getVersionColumns does not return resultset as per JDBC API specifications + + - Fixed Bug#44865 - getColumns does not return resultset as per JDBC API specifications + + - Fixed Bug#44868 - getTypeInfo does not return resultset as per JDBC API specifications + + - Fixed Bug#44869 - getIndexInfo does not return resultset as per JDBC API specifications + + - Fixed Bug#44867 - getImportedKeys/exportedKeys/crossReference doesn't have correct type for DEFERRABILITY + + - Fixed Bug#41730 - SQL Injection when using U+00A5 and SJIS + + - Fixed Bug#43196 - Statement.getGeneratedKeys() doesn't return values for UNSIGNED BIGINTS with values > Long.MAX_VALUE. + Unfortunately, because the server doesn't tell clients what TYPE the auto increment value is, the driver can't consistently + return BigIntegers for the result set returned from getGeneratedKeys(), it will only return them if the value is > Long.MAX_VALUE. + If your application needs this consistency, it will need to check the class of the return value from .getObject() on the + ResultSet returned by Statement.getGeneratedKeys() and if it's not a BigInteger, create one based on the java.lang.Long that + is returned. + + - Fixed Bug#38387 - "functionsNeverReturnBlobs=true" now works for SQL functions that return binary/binary collation VAR_STRINGS. + + - Fixed Bug#45171 - Connection.serverPrepareStatement() returns wrong default result set types + + - Fixed Bug #43714 - useInformationSchema with + DatabaseMetaData.getExportedKeys() throws exception + + - Fixed Bug #42253 - multiple escaped quotes cause exception from + EscapeProcessor + + - Fixed Bug #41566 - Quotes within comments not correctly ignored by + statement parser + + - Fixed Bug #41269 - DatabaseMetadata.getProcedureColumns() returns + wrong value for column length + + - Fixed Bug #40439 - Error rewriting batched statement if table name + ends with "values". + + - Fixed Bug #41484 Accessing fields by name after the ResultSet is closed throws + NullPointerException. + + - Fixed Bug #39426 - executeBatch passes most recent PreparedStatement params + to StatementInterceptor + + - Support use of INFORMATION_SCHEMA.PARAMETERS when "useInformationSchema" is set "true" and the view exists + for DatabaseMetaData.getProcedureColumns() and getFunctionColumns(). + + - When "logSlowQueries" is set to "true", and the driver has made a connection to a server that has suport + for the SERVER_QUERY_WAS_SLOW flag in the protocol, the query will be logged if the server indicates the + query has passed the slow query threshold. + + - Added new property, "maxAllowedPacket" to set maximum allowed packet size to + send to server. + +10-22-08 - Version 5.1.7 + - Fixed BUG#33861 - Added global blacklist for LoadBalancingConnectionProxy and + implemented in RandomBalanceStrategy and BestResponseTimeBalanceStrategy. + Added new property, "loadBalanceBlacklistTimeout", to control how long a + server lives in the global blacklist. + + - Fixed BUG#38782 - Possible IndexOutOfBoundsException in random load balancing + strategy. + + - Fixed BUG#39784 - invalidateCurrentConnection() does not manage global blacklist + when handling connection exceptions. + + - Fixed BUG#40031 - Adding support for CallableStatement.execute() to call + stored procedures that are defined as NO SQL or SQL READ DATA when failed + over to a read-only slave with replication driver. + + - Fixed BUG#35170- ResultSet.isAfterLast() doesn't work with for + streaming result sets. + + - Fixed BUG#35199 - Parse error for metadata in stored function. + + - Fixed BUG#35415 - When result set is from views without access to underlying + columns and is opened with CONCUR_UPDATABLE, don't throw SQLExceptions when + checking updatability due to access permissions, instead return + CONCUR_READONLY from getConcurrency. + + - Fixed BUG#35666 - NullPointerException when using "logSlowQueries=true" with + server-side prepared statements enabled. + + - Fixed BUG#35660 - Calling equals() on connections created with "jdbc:mysql:loadbalance:" + URLs did not have the same behavior as "plain" connections. The behavior we use + is the implementation in java.lang.Object, load-balanced connections just happened + to be using a java.lang.reflect.Proxy which required some custom behavior in + equals() to make it work the same as "plain" connections. + + Note that there is no *specified* equals contract for JDBC connections in the + JDBC specification itself, but the test makes sure that our implementation is + at least consistent. + + - Fixed BUG#35810 - Properties set in URLs and then passed to DataSources via setUrl() + did not take effect in certain circumstances. This also fixes related bugs BUG#13261 and + BUG#35753. + + - Fixed BUG#36051 - ResultSet.getTime() won't accept value of '24' for hours component of + a java.sql.Time. + + - Fixed BUG#36830 - DBMD.getColumns() doesn't return correct COLUMN_SIZE for SET columns. The + logic wasn't accounting for the ","s in the column size. + + - Fixed BUG#35610, BUG#35150- ResultSet.findColumn() and ResultSet.get...(String) doesn't allow + column names to be used, and isn't congruent with ResultSetMetadata.getColumnName(). + + By default, we follow the JDBC Specification here, in that the 4.0 behavior + is correct. Calling programs should use ResultSetMetaData.getColumnLabel() to dynamically determine + the correct "name" to pass to ResultSet.findColumn() or ResultSet.get...(String) whether or not the + query specifies an alias via "AS" for the column. ResultSetMetaData.getColumnName() will return the + actual name of the column, if it exists, and this name can *not* be used as input to ResultSet.findColumn() + or ResultSet.get...(String). + + The JDBC-3.0 (and earlier) specification has a bug, but you can get the buggy behavior + (allowing column names *and* labels to be used for ResultSet.findColumn() and get...(String)) by setting + "useColumnNamesInFindColumn" to "true". + + - Fixed BUG#35489 - Prepared statements from pooled connections cause NPE when closed() under JDBC-4.0. + + - Added connection property "useLocalTransactionState" which configures if the driver use the in-transaction + state provided by the MySQL protocol to determine if a commit() or rollback() should actually be sent to the database. + (disabled by default). + + - Use socket timeouts for JDBC-4.0's Connection.isValid(int timeout) instead of timer tasks, for scalability. As a side effect + internally, any communications with the database can use a timeout different than the configured timeout, but this isn't currently + used. + + - The number and position of columns for "SHOW INNODB STATUS" changed in MySQL-5.1, which caused the + "includeInnodbStatusInDeadlockExceptions" feature to not show data about the deadlock. + + - Implemented support of INFORMATION_SCHEMA for DatabaseMetadata.getTables() (views there are available as "SYSTEM TABLE"), and thus + also made INFORMATION_SCHEMA tables available via DatabaseMetadata.getColumns(). + + - Fixed BUG#39352, "INSERT ... ON DUPLICATE KEY UPDATE" doesn't return "0" for un-affected rows. This requires the driver to not + send the "CLIENT_FOUND_ROWS" flag to the server when it connects if the connection property "useAffectedRows" is set to "true", + which breaks JDBC-compliance, but currently there is no other way to get correct return values from the server. + + - Fixed BUG#38747 - ResultSets in "streaming" mode throw an exception when closed when the connection is set as "read-only". + + - Fixed BUG#37570 - Can't use non-latin1 passwords. Added connection property "passwordCharacterEncoding". Leaving this set to + the default value (null), uses the platform character set, which works for ISO8859_1 (i.e. "latin1") passwords. For passwords + in other character encodings, the encoding will have to be specified with this property, as it's not possible for the driver to + auto-detect this. + + - Fixed BUG#39911 - We don't retrieve nanos correctly when -parsing- a string for a TIMESTAMP. MySQL itself doesn't support micros + or nanos in timestamp values, but if they're stored as strings, historically we try and parse the nanos portion as well. + Unfortunately we -interpreted- them as micros. This fix includes correcting that behavior, and setting the milliseconds portion of + such TIMESTAMPs to a correct value as well. + + - Fixed BUG#39962 - ResultSet.findColumn() is slow for applications that call it too often (we're looking at -you- Hibernate). We're + using TreeMaps to get case-insensitive comparisons (required for JDBC compliance), but they can be slower than hash maps, so using the + approach Alex Burgel points out in this bug seems to help. + + - Fixed BUG#39956 - Statement.getGeneratedKeys() doesn't respect the 'auto_increment_increment' value. We now grab the *session-scoped* + value, and use that. Beware that using "cacheServerConfig=true" will cause us to cache this value, so new connections won't see changes + that are applied via something like "init-sql". + + - Fixed BUG#39611 - ReplicationConnection never sends queries to last host in slave list. + + - Fixed BUG#34185 - Statement.getGeneratedKeys() does not raise exception when statement was not + created with Statement.RETURN_GENERATED_KEYS flags. + + - Using autoGenerateTestcaseScript=true now logs all statements, regardless or not if they cause errors when processed by MySQL. + A "clock" value (millis since epoch) was added in the comment that is pre-pended with the idea that it can then be used + when post-processing output to sequence things correctly for a multi-threaded testcase, or to replay the test case with the + correct think times. + +03-06-08 - Version 5.1.6 + + - JDBC-4.0-ized XAConnections and datasources. + + - Fixed BUG#31790 MysqlValidConnectionChecker + doesn't properly handle ReplicationConnection + + - Fixed Bug#20491 - DatabaseMetadata.getColumns() doesn't + return correct column names if connection character set + isn't UTF-8. (There was a server-side component of this that + was fixed late in the 5.0 development cycle, it seems, this + is the last piece that fixes some loose ends in the JDBC + driver). This fix touches *all* metadata information coming + from the MySQL server itself. + + - Fixed MysqlIO.nextRowFast() to only attempt to read server + warning counts and status if talking to a 4.1 or newer server + (fixes a hang when reading data from 4.0 servers). + + - Made profiler event handling extensible via the "profilerEventHandler" + connection property. + + - Fixed Bug#31823 - CallableStatement.setNull() on a stored function would + throw an ArrayIndexOutOfBounds when setting the last parameter to null when calling setNull(). + + - Added SSL-related configuration property "verifyServerCertificate". If set to "false", the driver won't verify + the server's certificate when "useSSL" is set to "true". + + When using this feature, the keystore parameters should be specified by the + "clientCertificateKeyStore*" properties, rather than system properties, as the JSSE doesn't + make it straightforward to have a non-verifying trust store and the "default" key store. + + - Fixed ResultSetMetadata.getColumnName() for result sets returned from + Statement.getGeneratedKeys() - it was returning null instead of + "GENERATED_KEY" as in 5.0.x. + + - More applicable fix for the "random" load balance strategy in the face + of node non-responsive, it re-tries a *different* random node, rather + than waiting for the node to recover (for BUG#31053) + + - Fixed BUG#32577 - no way to store two timestamp/datetime values that happens + over the DST switchover, as the hours end up being the same when sent as + the literal that MySQL requires. + + Note that to get this scenario to work with MySQL (since it doesn't support + per-value timezones), you need to configure your server (or session) to be in UTC, + and tell the driver not to use the legacy date/time code by setting + "useLegacyDatetimeCode" to "false". This will cause the driver to always convert + to/from the server and client timezone consistently. + + This bug fix also fixes BUG#15604, by adding entirely new date/time handling + code that can be switched on by "useLegacyDatetimeCode" being set to "false" as + a JDBC configuration property. For Connector/J 5.1.x, the default is "true", + in trunk and beyond it will be "false" (i.e. the old date/time handling code, warts + and all will be deprecated). + + - Fixed BUG#32877 - Load balancing connection using best response time would incorrectly + "stick" to hosts that were down when the connection was first created. + + We solve this problem with a black list that is used during the picking of new hosts. + If the black list ends up including all configured hosts, the driver will retry for + a configurable number of times (the "retriesAllDown" configuration property, with a default + of 120 times), sleeping 250ms between attempts to pick a new connection. + + We've also went ahead and made the balancing strategy extensible. To create a new strategy, + implement the interface com.mysql.jdbc.BalanceStrategy (which also includes our standard + "extension" interface), and tell the driver to use it by passing in the + class name via the "loadBalanceStrategy" configuration property. + + - Fixed BUG#30508 - ResultSet returned by Statement.getGeneratedKeys() is not closed + automatically when statement that created it is closed. + + - Added two new connection properties, "selfDestructOnPingSecondsLifetime" and + "selfDestructOnPingMaxOperations" designed to control overall connection lifetime + (useful to reclaim resources on the server side) for connection pools that don't have such a + facility. + + The driver will consult the values of these properties when a ping is sent, either through + calling Connection.ping(), issuing the "ping marker" query (any query that starts with + "/* ping */"), or when using JDBC-4.0, calling Connection.isValid(). + + If the connection has issued too many operations, or is too old, the driver will + throw a SQLException with the SQLState of "08S01" at the time of the ping, which + will cause the connection to be invalidated with most pools in use today. + + - Fixed issue where driver could send invalid server-side prepared statement + IDs to the server when the driver was setup to do auto-reconnect as the + connection could get set up enough to start sending queries on one thread, + while the thread that "noticed" the connection was down hasn't completed + re-preparing all of the server-side prepared statements that were open when + the connection died. + + Potentially fixes cause for bug 28934. Potentially fixes other possible race + conditions where one thread that has created a connection "shares" it with other + threads if the connection is reconnected due to auto-reconnect functionality. + + - Fixed BUG#33823 - Public interface ResultSetInternalMethods with reference to + non-public class com.mysql.jdbc.CachedResultSetMetaData. + + - For any SQLException caused by another Throwable, besides dumping the message or stack + trace as a string into the message, set the underlying Throwable as the cause for + the SQLException, making it accessible via getCause(). + + - Fixed BUG#34093 - Statements with batched values do not return correct values for + getGeneratedKeys() when "rewriteBatchedStatements" is set to "true", and the + statement has an "ON DUPLICATE KEY UPDATE" clause. + + - Fixed BUG#31192 - Encoding Issue retrieving serverVersion in MysqlIO in the + method doHandshake when encoding doesn't contain ASCII characters in the "standard" + place (i.e. ebcdic). + + - Fixed issue where META-INF in the binary .jar file wasn't packed correctly, + leading to failure of the JDBC-4.0 SPI mechanism. + + - CallableStatements that aren't really stored procedure or stored function calls can + now be used, for tools such as Oracle JDeveloper ADF that issue statements such as + DDL through CallableStatements. + + - Fixed BUG#34518 - Statements using cursor fetch leaked internal prepared statements + until connection was closed. The internal prepared statement is now held open while + the result set is open, and closed by the result set itself being closed. + + - Fixed BUG#34677 - Blob.truncate() wouldn't take "0" as an argument. + + - CommunicationExceptions now carry information about the last time a packet + was received from the MySQL server, as well as when the last packet was sent + to one, in an effort to make it easier to debug communications errors caused + by network timeouts. + + - Reverted a change to DatabaseMetadata.getColumns() from 5.0, where + getColumns() would report NULL for COLUMN_SIZE for TIME, DATE, DATETIME + and TIMESTAMP types. It now reports the column size, in the + DatabaseMetadata implementations that use "SHOW" commands, and the + INFORMATION_SCHEMA. + + - Fixed Bug#34762 - RowDataStatic does't always set the metadata in + ResultSetRow, which can lead to failures when unpacking DATE, + TIME, DATETIME and TIMESTAMP types when using absolute, relative, + and previous result set navigation methods. + + - Fixed BUG#34703 - Connection.isValid() invalidates connection after + timeout, even if connection is actually valid. + + - Fixed BUG#34194 - ResultSetMetaData.getColumnTypeName() returns + "UNKNOWN" for GEOMETRY type. + + - Fixed BUG#33162 - NullPointerException instead of SQLException + thrown for ResultSet.getTimestamp() when not positioned on a + row. + + - The ConnectionLifecycleInterceptor interface now has callback methods for + transaction initiation (transactionBegun()), and completion + (transactionCompleted()), as reported by the *server* (i.e. + calling Connection.setAutoCommit(false) will not trigger + transactionBegun() being called, however the first statement + which causes a transaction to start on the server will cause + transactionBegun() to be called *after* the statement has been processed + on the server). + + - Fixed Bug#34913 - ResultSet.getTimestamp() returns incorrect + values for month/day of TIMESTAMPs when using server-side + prepared statements (not enabled by default). + + - Fixed BUG#34937 - MysqlConnectionPoolDataSource does not support + ReplicationConnection. Notice that we implemented com.mysql.jdbc.Connection + for ReplicationConnection, however, only accessors from ConnectionProperties + are implemented (not the mutators), and they return values from the currently + active connection. All other methods from com.mysql.jdbc.Connection are + implemented, and operate on the currently active connection, with the exception of + resetServerState() and changeUser(). + + - Connections created with jdbc:mysql:replication:// URLs now force + roundRobinLoadBalance=true on the slaves, and round-robin loadbalancing + now uses a "random" choice to more evenly distribute load across slave + servers, especially in connection pools. Connections that are configured + with "roundRobinLoadBalance=true" no longer set the failover state, + as it's assumed that we're not attempting to fall-back to a master + server. This fixes BUG#34963. + +10-09-07 - Version 5.1.5 + + - Released instead of 5.1.4 to pickup patch for BUG#31053 + from 5.0.8. + +10-09-07 - Version 5.1.4 + + - Added "autoSlowLog" configuration property, overrides + "slowQueryThreshold*" properties, driver determines slow + queries by those that are slower than 5 * stddev of the mean + query time (outside the 96% percentile). + + - Fixed BUG#28256 - When connection is in read-only mode, + queries that are wrapped in parentheses incorrectly identified + as DML. + +09-07-07 - Version 5.1.3 RC + + - Setting "useBlobToStoreUTF8OutsideBMP" to "true" tells the + driver to treat [MEDIUM/LONG/TINY]BLOB columns as [LONG]VARCHAR + columns holding text encoded in UTF-8 that has characters + outside the BMP (4-byte encodings), which MySQL server + can't handle natively. + + Set "utf8OutsideBmpExcludedColumnNamePattern" to a regex so that + column names matching the given regex will still be treated + as BLOBs The regex must follow the patterns used for the + java.util.regex package. The default is to exclude no columns, + and include all columns. + + Set "utf8OutsideBmpIncludedColumnNamePattern" to specify exclusion + rules to "utf8OutsideBmpExcludedColumnNamePattern". The regex must + follow the patterns used for the java.util.regex package. + + - New methods on com.mysql.jdbc.Statement: setLocalInfileInputStream() + and getLocalInfileInputStream(). + + setLocalInfileInputStream() sets an InputStream instance that will be used to send data + to the MySQL server for a "LOAD DATA LOCAL INFILE" statement + rather than a FileInputStream or URLInputStream that represents + the path given as an argument to the statement. + + This stream will be read to completion upon execution of a + "LOAD DATA LOCAL INFILE" statement, and will automatically + be closed by the driver, so it needs to be reset + before each call to execute*() that would cause the MySQL + server to request data to fulfill the request for + "LOAD DATA LOCAL INFILE". + + If this value is set to NULL, the driver will revert to using + a FileInputStream or URLInputStream as required. + + getLocalInfileInputStream() returns the InputStream instance that will be used to send + data in response to a "LOAD DATA LOCAL INFILE" statement. + + This method returns NULL if no such stream has been set + via setLocalInfileInputStream(). + + - The driver now connects with an initial character set + of "utf-8" solely for the purposes of authentication to + allow usernames and database names in any character set to + be used in the JDBC URL. + + - Errors encountered during Statement/PreparedStatement/CallableStatement.executeBatch() + when "rewriteBatchStatements" has been set to "true" now return + BatchUpdateExceptions according to the setting of "continueBatchOnError". + + If "continueBatchOnError" is set to "true", the update counts for the + "chunk" that were sent as one unit will all be set to EXECUTE_FAILED, but + the driver will attempt to process the remainder of the batch. You can determine which + "chunk" failed by looking at the update counts returned in the BatchUpdateException. + + If "continueBatchOnError" is set to "false", the update counts returned + will contain the failed "chunk", and stop with the failed chunk, with all + counts for the failed "chunk" set to EXECUTE_FAILED. + + Since MySQL doesn't return multiple error codes for multiple-statements, or + for multi-value INSERT/REPLACE, it is the application's responsibility to handle + determining which item(s) in the "chunk" actually failed. + + - Statement.setQueryTimeout()s now affect the entire batch for batched + statements, rather than the individual statements that make up the batch. + +06-29-07 - Version 5.1.2 Beta + + - Setting the configuration property "rewriteBatchedStatements" + to "true" will now cause the driver to rewrite batched prepared + statements with more than 3 parameter sets in a batch into + multi-statements (separated by ";") if they are not plain + (i.e. without SELECT or ON DUPLICATE KEY UPDATE clauses) INSERT + or REPLACE statements. + +06-22-07 - Version 5.1.1 Alpha + + - Pulled vendor-extension methods of Connection implementation out + into an interface to support java.sql.Wrapper functionality from + ConnectionPoolDataSource. The vendor extensions are javadoc'd in + the com.mysql.jdbc.Connection interface. + + For those looking further into the driver implementation, it is not + an API that is used for plugability of implementations inside our driver + (which is why there are still references to ConnectionImpl throughout the + code). + + Incompatible change: Connection.serverPrepare(String) has been re-named + to Connection.serverPrepareStatement() for consistency with + Connection.clientPrepareStatement(). + + We've also added server and client prepareStatement() methods that cover + all of the variants in the JDBC API. + + - Similar to Connection, we pulled out vendor extensions to Statement + into an interface named "com.mysql.Statement", and moved the Statement + class into com.mysql.StatementImpl. The two methods (javadoc'd in + "com.mysql.Statement" are enableStreamingResults(), which already existed, + and disableStreamingResults() which sets the statement instance back to + the fetch size and result set type it had before enableStreamingResults() + was called. + + - Added experimental support for statement "interceptors" via the + com.mysql.jdbc.StatementInterceptor interface, examples are + in com/mysql/jdbc/interceptors. + + Implement this interface to be placed "in between" query execution, so that + you can influence it. (currently experimental). + + StatementInterceptors are "chainable" when configured by the user, the + results returned by the "current" interceptor will be passed on to the next + on in the chain, from left-to-right order, as specified by the user in the + JDBC configuration property "statementInterceptors". + + See the sources (fully javadoc'd) for com.mysql.jdbc.StatementInterceptor + for more details until we iron out the API and get it documented in the + manual. + + - Externalized the descriptions of connection properties. + + - The data (and how it's stored) for ResultSet rows are now behind an + interface which allows us (in some cases) to allocate less memory + per row, in that for "streaming" result sets, we re-use the packet + used to read rows, since only one row at a time is ever active. + + - Made it possible to retrieve prepared statement parameter bindings + (to be used in StatementInterceptors, primarily). + + - Row navigation now causes any streams/readers open on the result set + to be closed, as in some cases we're reading directly from a shared network + packet and it will be overwritten by the "next" row. + + - Setting "rewriteBatchedStatements" to "true" now causes CallableStatements + with batched arguments to be re-written in the form "CALL (...); CALL (...); ..." + to send the batch in as few client-server round trips as possible. + + - Driver now picks appropriate internal row representation (whole row in one + buffer, or individual byte[]s for each column value) depending on heuristics, + including whether or not the row has BLOB or TEXT types and the overall + row-size. The threshold for row size that will cause the driver to + use a buffer rather than individual byte[]s is configured by the + configuration property "largeRowSizeThreshold", which has a default + value of 2KB. + +04-11-07 - Version 5.1.0 Alpha + + - Bumped JDBC Specification version number in jar-file manifest. + + - Re-worked Ant buildfile to build JDBC-4.0 classes separately, as well + as support building under Eclipse (since Eclipse can't mix/match JDKs). + + To build, you must set JAVA_HOME to J2SDK-1.4.2 or Java-5, and set + the following properties on your Ant commandline: + + com.mysql.jdbc.java6.javac - full path to your Java-6 javac executable + com.mysql.jdbc.java6.rtjar - full path to your Java-6 rt.jar file + + - New feature - driver will automatically adjust session variable + "net_write_timeout" when it determines its been asked for a "streaming" + result, and resets it to the previous value when the result set + has been consumed. (configuration property is named + "netTimeoutForStreamingResults", value has unit of seconds, + the value '0' means the driver will not try and adjust this value). + + - Added support for JDBC-4.0 categorized SQLExceptions. + + - Refactored CommunicationsException into a JDBC3 version, and a JDBC4 + version (which extends SQLRecoverableException, now that it exists). + + This change means that if you were catching + com.mysql.jdbc.CommunicationsException in your applications instead + of looking at the SQLState class of "08", and are moving to Java 6 + (or newer), you need to change your imports to that exception + to be com.mysql.jdbc.exceptions.jdbc4.CommunicationsException, as + the old class will not be instantiated for communications link-related + errors under Java 6. + + - Added support for JDBC-4.0's client information. The backend storage + of information provided via Connection.setClientInfo() and retrieved + by Connection.getClientInfo() is pluggable by any class that implements + the com.mysql.jdbc.JDBC4ClientInfoProvider interface and has a no-args + constructor. + + The implementation used by the driver is configured using the + "clientInfoProvider" configuration property (with a default of value + of "com.mysql.jdbc.JDBC4CommentClientInfoProvider", an implementation + which lists the client info as a comment prepended to every query + sent to the server). + + This functionality is only available when using Java-6 or newer. + + - Added support for JDBC-4.0's SQLXML interfaces. + + - Added support for JDBC-4.0's Wrapper interface. + + - Added support for JDBC-4.0's NCLOB, and NCHAR/NVARCHAR types. + +nn-nn-07 - Version 5.0.9 + + - Driver now calls SocketFactory.afterHandshake() at appropriate time. + +10-09-07 - Version 5.0.8 + + - Fixed BUG#30550, executeBatch() would fail with an ArithmeticException + and/or NullPointerException when the batch had zero members and + "rewriteBatchedStatements" was set to "true" for the connection. + + - Added two configuration parameters (both default to "false") + + * blobsAreStrings - Should the driver always treat BLOBs as Strings + specifically to work around dubious metadata returned + by the server for GROUP BY clauses? + + * functionsNeverReturnBlobs - Should the driver always treat data from + functions returning BLOBs as Strings - + specifically to work around dubious metadata + returned by the server for GROUP BY clauses? + + - Fixed BUG#29106 - Connection checker for JBoss didn't use same method parameters + via reflection, causing connections to always seem "bad". + + - Fixed BUG#30664 - Note that this fix only works for MySQL server + versions 5.0.25 and newer, since earlier versions didn't consistently + return correct metadata for functions, and thus results from + subqueries and functions were indistinguishable from each other, + leading to type-related bugs. + + - Fixed BUG#28972 - DatabaseMetaData.getTypeInfo() for the types DECIMAL + and NUMERIC will return a precision of 254 for server versions older than + 5.0.3, 64 for versions 5.0.3-5.0.5 and 65 for versions newer than 5.0.5. + + - Fixed BUG#29852 - Closing a load-balanced connection would cause a + ClassCastException. + + - Fixed BUG#27867 - Schema objects with identifiers other than + the connection character aren't retrieved correctly in + ResultSetMetadata. + + - Fixed BUG#28689 - CallableStatement.executeBatch() doesn't work when + connection property "noAccessToProcedureBodies" has been set to "true". + + The fix involves changing the behavior of "noAccessToProcedureBodies",in + that the driver will now report all paramters as "IN" paramters + but allow callers to call registerOutParameter() on them without throwing + an exception. + + - Fixed BUG#27182 - Connection.getServerCharacterEncoding() doesn't work + for servers with version >= 4.1. + + - Fixed BUG#27915 - DatabaseMetaData.getColumns() doesn't + contain SCOPE_* or IS_AUTOINCREMENT columns. + + - Fixed BUG#30851, NPE with null column values when + "padCharsWithSpace" is set to "true". + + - Specifying a "validation query" in your connection pool + that starts with "/* ping */" _exactly_ will cause the driver to + instead send a ping to the server and return a fake result set (much + lighter weight), and when using a ReplicationConnection or a LoadBalancedConnection, + will send the ping across all active connections. + + - Fixed Bug#30892 setObject(int, Object, int, int) delegate in + PreparedStatmentWrapper delegates to wrong method. + + - XAConnections now start in auto-commit mode (as per JDBC-4.0 specification + clarification). + + - Fixed Bug#27412 - cached metadata with PreparedStatement.execute() + throws NullPointerException. + + - Driver will now fall back to sane defaults for max_allowed_packet and + net_buffer_length if the server reports them incorrectly (and will log + this situation at WARN level, since it's actually an error condition). + + - Fixed BUG#27916 - UNSIGNED types not reported via DBMD.getTypeInfo(), and + capitalization of type names is not consistent between DBMD.getColumns(), + RSMD.getColumnTypeName() and DBMD.getTypeInfo(). + + This fix also ensures that the precision of UNSIGNED MEDIUMINT + and UNSIGNED BIGINT is reported correctly via DBMD.getColumns(). + + - Fixed BUG#31053 - Connections established using URLs of the form + "jdbc:mysql:loadbalance://" weren't doing failover if they tried to + connect to a MySQL server that was down. The driver now attempts + connections to the next "best" (depending on the load balance strategy + in use) server, and continues to attempt connecting to the next "best" + server every 250 milliseconds until one is found that is up and running + or 5 minutes has passed. + + If the driver gives up, it will throw the last-received SQLException. + +07-19-07 - Version 5.0.7 + + - Setting the configuration parameter "useCursorFetch" to "true" for + MySQL-5.0+ enables the use of cursors that allow Connector/J to save + memory by fetching result set rows in chunks (where the chunk size + is set by calling setFetchSize() on a Statement or ResultSet) by + using fully-materialized cursors on the server. + + The driver will will now automatically set "useServerPrepStmts" to + "true" when "useCursorFetch" has been set to "true", since the feature + requires server-side prepared statements in order to function. + + - Fixed BUG#28469 - PreparedStatement.getMetaData() for statements + containing leading one-line comments is not returned correctly. + + As part of this fix, we also overhauled detection of DML for + executeQuery() and SELECTs for executeUpdate() in plain and + prepared statements to be aware of the same types of comments. + + - Added configuration property "useNanosForElapsedTime" - for + profiling/debugging functionality that measures elapsed time, + should the driver try to use nanoseconds resolution if available + (requires JDK >= 1.5)? + + - Added configuration property "slowQueryThresholdNanos" - if + "useNanosForElapsedTime" is set to "true", and this property + is set to a non-zero value the driver will use this threshold + (in nanosecond units) to determine if a query was slow, instead + of using millisecond units. + + Note, that if "useNanosForElapsedTime" is set to "true", and this + property is set to "0" (or left default), then elapsed times will + still be measured in nanoseconds (if possible), but the slow query + threshold will be converted from milliseconds to nanoseconds, and thus + have an upper bound of approximately 2000 millesconds (as that threshold + is represented as an integer, not a long). + + - Added configuration properties to allow tuning of TCP/IP socket + parameters: + + "tcpNoDelay" - Should the driver set SO_TCP_NODELAY (disabling the + Nagle Algorithm, default "true")? + + "tcpKeepAlive" - Should the driver set SO_KEEPALIVE (default "true")? + + "tcpRcvBuf" - Should the driver set SO_RCV_BUF to the given value? + The default value of '0', means use the platform default + value for this property. + + "tcpSndBuf" - Should the driver set SO_SND_BUF to the given value? + The default value of '0', means use the platform default + value for this property. + + "tcpTrafficClass" - Should the driver set traffic class or + type-of-service fields? See the documentation + for java.net.Socket.setTrafficClass() for more + information. + + - Give more information in EOFExceptions thrown out of MysqlIO (how many + bytes the driver expected to read, how many it actually read, say that + communications with the server were unexpectedly lost). + + - Setting "useDynamicCharsetInfo" to "false" now causes driver to use + static lookups for collations as well (makes + ResultSetMetadata.isCaseSensitive() much more efficient, which leads + to performance increase for ColdFusion, which calls this method for + every column on every table it sees, it appears). + + - Driver detects when it is running in a ColdFusion MX server (tested + with version 7), and uses the configuration bundle "coldFusion", + which sets useDynamicCharsetInfo to "false" (see previous entry), and + sets useLocalSessionState and autoReconnect to "true". + + - Fixed BUG#28851 - parser in client-side prepared statements + eats character following '/' if it's not a multi-line comment. + + - Fixed BUG#28956 - parser in client-side prepared statements + runs to end of statement, rather than end-of-line for '#' comments. + + Also added support for '--' single-line comments. + + - Don't send any file data in response to LOAD DATA LOCAL INFILE + if the feature is disabled at the client side. This is to prevent + a malicious server or man-in-the-middle from asking the client for + data that the client is not expecting. Thanks to Jan Kneschke for + discovering the exploit and Andrey "Poohie" Hristov, Konstantin Osipov + and Sergei Golubchik for discussions about implications and possible + fixes. This fixes BUG 29605 for JDBC. + + - Added new debugging functionality - Setting configuration property + "includeInnodbStatusInDeadlockExceptions" to "true" will cause the driver + to append the output of "SHOW ENGINE INNODB STATUS" to deadlock-related + exceptions, which will enumerate the current locks held inside InnoDB. + +05-15-07 - Version 5.0.6 + + - Fixed BUG#25545 - Client options not sent correctly when using SSL, + leading to stored procedures not being able to return results. Thanks + to Don Cohen for the bug report, testcase and patch. + + - Fixed BUG#26592 - PreparedStatement is not closed in + BlobFromLocator.getBytes(). + + - Fixed BUG#25624 - Whitespace surrounding storage/size specifiers in + stored procedure parameters declaration causes NumberFormatException to + be thrown when calling stored procedure on JDK-1.5 or newer, as the Number + classes in JDK-1.5+ are whitespace intolerant. + + - Fixed BUG#26173 - When useCursorFetch=true, sometimes server would return + new, more exact metadata during the execution of the server-side prepared + statement that enables this functionality, which the driver ignored (using + the original metadata returned during prepare()), causing corrupt reading + of data due to type mismatch when the actual rows were returned. + + - Fixed BUG#26959 - comments in DDL of stored procedures/functions confuse + procedure parser, and thus metadata about them can not be created, leading to + inability to retrieve said metadata, or execute procedures that have certain + comments in them. + + - Give better error message when "streaming" result sets, and the connection + gets clobbered because of exceeding net_write_timeout on the server. (which is + basically what the error message says too). + + - Fixed BUG#26789 - fast date/time parsing doesn't take into + account 00:00:00 as a legal value. + + - Fixed BUG#27317 - ResultSet.get*() with a column index < 1 returns + misleading error message. + + - Fixed BUG#25517 - Statement.setMaxRows() is not effective on result + sets materialized from cursors. + + - New configuration property, "enableQueryTimeouts" (default "true"). + When enabled, query timeouts set via Statement.setQueryTimeout() use a + shared java.util.Timer instance for scheduling. Even if the timeout + doesn't expire before the query is processed, there will be + memory used by the TimerTask for the given timeout which won't be + reclaimed until the time the timeout would have expired if it + hadn't been cancelled by the driver. High-load environments + might want to consider disabling this functionality. (this configuration + property is part of the "maxPerformance" configuration bundle). + + - Fixed BUG#27400 - CALL /* ... */ some_proc() doesn't work. As a side effect + of this fix, you can now use /* */ and # comments when preparing statements using + client-side prepared statement emulation. + + If the comments happen to contain parameter markers '?', they will be treated + as belonging to the comment (i.e. not recognized) rather than being a parameter + of the statement. + + Note that the statement when sent to the server will contain the comments + as-is, they're not stripped during the process of preparing the PreparedStatement + or CallableStatement. + + - Fixed BUG#25328 - BIT(> 1) is returned as java.lang.String from ResultSet.getObject() + rather than byte[]. + + - Fixed BUG#25715 - CallableStatements with OUT/INOUT parameters that + are "binary" (blobs, bits, (var)binary, java_object) have extra 7 bytes + (which happens to be the _binary introducer!) + + - Added configuration property "padCharsWithSpace" (defaults to "false"). If set + to "true", and a result set column has the CHAR type and the value does not + fill the amount of characters specified in the DDL for the column, the driver + will pad the remaining characters with space (for ANSI compliance). + + - Fixed BUG#27655 - Connection.getTransactionIsolation() uses + "SHOW VARIABLES LIKE" which is very inefficient on MySQL-5.0+ + + - Added configuration property "useDynamicCharsetInfo". If set to "false" + (the default), the driver will use a per-connection cache of character set + information queried from the server when necessary, or when set to "true", + use a built-in static mapping that is more efficient, but isn't aware of + custom character sets or character sets implemented after the release of + the JDBC driver. + + Note: this only affects the "padCharsWithSpace" configuration property and the + ResultSetMetaData.getColumnDisplayWidth() method. + + - More intelligent initial packet sizes for the "shared" packets are used + (512 bytes, rather than 16K), and initial packets used during handshake are + now sized appropriately as to not require reallocation. + + - Fixed issue where calling getGeneratedKeys() on a prepared statement after + calling execute() didn't always return the generated keys (executeUpdate() + worked fine however). + + - Fixed issue where a failed-over connection would let an application call + setReadOnly(false), when that call should be ignored until the connection + is reconnected to a writable master unless "failoverReadOnly" had been set + to "false". + + - Fixed BUG#28085 - Generate more useful error messages for diagnostics + when the driver thinks a result set isn't updatable. (Thanks to Ashley Martens + for the patch). + + - Driver will now use INSERT INTO ... VALUES (DEFAULT) form of statement + for updatable result sets for ResultSet.insertRow(), rather than + pre-populating the insert row with values from DatabaseMetaData.getColumns() + (which results in a "SHOW FULL COLUMNS" on the server for every result + set). If an application requires access to the default values before + insertRow() has been called, the JDBC URL should be configured with + "populateInsertRowWithDefaultValues" set to "true". + + This fix specifically targets performance issues with ColdFusion and the + fact that it seems to ask for updatable result sets no matter what the + application does with them. + + - com.mysql.jdbc.[NonRegistering]Driver now understands URLs of the format + "jdbc:mysql:replication://" and "jdbc:mysql:loadbalance://" which will + create a ReplicationConnection (exactly like when + using [NonRegistering]ReplicationDriver) and an experimenal load-balanced + connection designed for use with SQL nodes in a MySQL Cluster/NDB environment, + respectively. + + In an effort to simplify things, we're working on deprecating multiple + drivers, and instead specifying different core behavior based upon JDBC URL + prefixes, so watch for [NonRegistering]ReplicationDriver to eventually + disappear, to be replaced with com.mysql.jdbc[NonRegistering]Driver with + the new URL prefix. + + - Added an experimental load-balanced connection designed for use with SQL nodes + in a MySQL Cluster/NDB environment (This is not for master-slave replication. + For that, we suggest you look at ReplicationConnection or "lbpool"). + + If the JDBC URL starts with "jdbc:mysql:loadbalance://host-1,host-2,...host-n", + the driver will create an implementation of java.sql.Connection that load + balances requests across a series of MySQL JDBC connections to the given hosts, + where the balancing takes place after transaction commit. + + Therefore, for this to work (at all), you must use transactions, even if only + reading data. + + Physical connections to the given hosts will not be created until needed. + + The driver will invalidate connections that it detects have had + communication errors when processing a request. A new connection to the + problematic host will be attempted the next time it is selected by the load + balancing algorithm. + + There are two choices for load balancing algorithms, which may be specified + by the "loadBalanceStrategy" JDBC URL configuration property: + + * "random" - the driver will pick a random host for each request. This tends + to work better than round-robin, as the randomness will somewhat account for + spreading loads where requests vary in response time, while round-robin + can sometimes lead to overloaded nodes if there are variations in response times + across the workload. + + * "bestResponseTime" - the driver will route the request to the host that had + the best response time for the previous transaction. + + - When "useLocalSessionState" is set to "true" and connected to a MySQL-5.0 or + later server, the JDBC driver will now determine whether an actual "commit" or + "rollback" statement needs to be sent to the database when Connection.commit() + or Connection.rollback() is called. + + This is especially helpful for high-load situations with connection pools that + always call Connection.rollback() on connection check-in/check-out because it + avoids a round-trip to the server. + +03-01-07 - Version 5.0.5 + + - Fixed BUG#23645 - Some collations/character sets reported as "unknown" + (specifically cias variants of existing character sets), and inability to override + the detected server character set. + + - Performance enhancement of initial character set configuration, driver + will only send commands required to configure connection character set + session variables if the current values on the server do not match + what is required. + + - Fixed BUG#24360 .setFetchSize() breaks prepared SHOW and other commands. + + - Fixed BUG#24344 - useJDBCCompliantTimezoneShift with server-side prepared + statements gives different behavior than when using client-side prepared + statements. (this is now fixed if moving from server-side prepared statements + to client-side prepared statements by setting "useSSPSCompatibleTimezoneShift" to + true", as the driver can't tell if this is a new deployment that never used + server-side prepared statements, or if it is an existing deployment that is + switching to client-side prepared statements from server-side prepared statements. + + - Fixed BUG#23304 - DBMD using "show" and DBMD using information_schema do + not return results consistent with each other. (note this fix only + addresses the inconsistencies, not the issue that the driver is + treating schemas differently than some users expect. We will revisit + this behavior when there is full support for schemas in MySQL). + + - Fixed BUG#25073 - rewriting batched statements leaks internal statement + instances, and causes a memory leak. + + - Fixed issue where field-level for metadata from DatabaseMetaData when using + INFORMATION_SCHEMA didn't have references to current connections, + sometimes leading to NullPointerExceptions when intropsecting them via + ResultSetMetaData. + + - Fixed BUG#25025 - Client-side prepared statement parser gets confused by + in-line (/* ... */) comments and therefore can't rewrite batched statements + or reliably detect type of statements when they're used. + + - Fixed BUG#24065 - Better error message when server doesn't return enough + information to determine stored procedure/function parameter types. + + - Fixed BUG#21438 - Driver sending nanoseconds to server for timestamps when + using server-side prepared statements, when server expects microseconds. + + - Fixed BUG#25514 - Timer instance used for Statement.setQueryTimeout() + created per-connection, rather than per-VM, causing memory leak + + - Fixed BUG#25009 - Results from updates not handled correctly in + multi-statement queries, leading to erroneous "Result is from UPDATE" + exceptions. + + - Fixed BUG#25047 - StringUtils.indexOfIgnoreCaseRespectQuotes() isn't + case-insensitive on the first character of the target. This bug broke + rewriteBatchedStatements functionality when prepared statements don't + use upper-case for the VALUES clause in their statements. + + - Fixed BUG#21480 - Some exceptions thrown out of StandardSocketFactory + were needlessly wrapped, obscurring their true cause, especially when + using socket timeouts. + + - Fixed BUG#23303 - DatabaseMetaData.getSchemas() doesn't return a + TABLE_CATALOG column. + + - Fixed BUG#25399 - EscapeProcessor gets confused by multiple + backslashes. We now push the responsibility of syntax errors back + on to the server for most escape sequences. + + - Fixed BUG#25379 - INOUT parameters in CallableStatements get + doubly-escaped. + + - Removed non-short-circuited logical ORs from "if" statements. + + - Re-worked stored procedure parameter parser to be more robust. Driver no + longer requires "BEGIN" in stored procedure definition, but does have + requirement that if a stored function begins with a label directly after the + "returns" clause, that the label is not a quoted identifier. + - Reverted back to internal character conversion routines for single-byte + character sets, as the ones internal to the JVM are using much more CPU + time than our internal implementation. + + - Changed cached result set metadata (when using + "cacheResultSetMetadata=true") to be cached per-connection rather + than per-statement as previously implemented. + + - Use a java.util.TreeMap to map column names to ordinal indexes for + ResultSet.findColumn() instead of a HashMap. This allows us to have + case-insensitive lookups (required by the JDBC specification) without + resorting to the many transient object instances needed to support this + requirement with a normal HashMap with either case-adjusted keys, or + case-insensitive keys. (In the worst case scenario for lookups of a 1000 + column result set, TreeMaps are about half as fast wall-clock time as + a HashMap, however in normal applications their use gives many orders + of magnitude reduction in transient object instance creation which pays + off later for CPU usage in garbage collection). + + - Avoid static synchronized code in JVM class libraries for dealing with + default timezones. + + - Fixed cases where ServerPreparedStatements weren't using cached metadata + when "cacheResultSetMetadata=true" was configured. + + - Use faster datetime parsing for ResultSets that come from plain or + non-server-side prepared statements. (Enable old implementation with + "useFastDateParsing=false" as a configuration parameter). + + - Fixed BUG#24794 - DatabaseMetaData.getSQLKeywords() doesn't return + all reserved words for current MySQL version. The current fix/implementation + returns keywords for MySQL-5.1, and doesn't distinguish between different + versions of the server. + + - When using cached metadata, skip field-level metadata packets coming from + the server, rather than reading them and discarding them without creating + com.mysql.jdbc.Field instances. + + - Fixed BUG#25836 - Statement execution which timed out doesn't always + throw MySQLTimeoutException. + + - Throw exceptions encountered during timeout to thread + calling Statement.execute*(), rather than RuntimeException. + + - Added configuration property "localSocketAddress",which is the hostname or + IP address given to explicitly configure the interface that the driver will + bind the client side of the TCP/IP connection to when connecting. + + - Take "localSocketAddress" property into account when creating instances + of CommunicationsException when the underyling exception is a + java.net.BindException, so that a friendlier error message is given with + a little internal diagnostics. + + - Fixed some NPEs when cached metadata was used with UpdatableResultSets. + + - The "rewriteBatchedStatements" feature can now be used with server-side + prepared statements. + + - Fixed BUG#26326 - Connection property "socketFactory" wasn't exposed via + correctly named mutator/accessor, causing data source implementations that + use JavaBean naming conventions to set properties to fail to set the property + (and in the case of SJAS, fail silently when trying to set this parameter). + + - Fixed BUG#25787 - java.util.Date should be serialized for + PreparedStatement.setObject(). + + We've added a new configuration option "treatUtilDateAsTimestamp", which is + false by default, as (1) We already had specific behavior to treat + java.util.Date as a java.sql.Timestamp because it's useful to many folks, + and (2) that behavior will very likely be required for drivers JDBC-post-4.0. + + - Fixed BUG#22628 - Driver.getPropertyInfo() throws NullPointerException for + URL that only specifies host and/or port. + + - Fixed BUG#21267, ParameterMetaData throws NullPointerException when + prepared SQL actually has a syntax error. Added + "generateSimpleParameterMetadata" configuration property, which when set + to "true" will generate metadata reflecting VARCHAR for every parameter + (the default is "false", which will cause an exception to be thrown if no + parameter metadata for the statement is actually available). + + - When extracting foreign key information from "SHOW CREATE TABLE " in + DatabaseMetaData, ignore exceptions relating to tables being missing + (which could happen for cross-reference or imported-key requests, as + the list of tables is generated first, then iterated). + + - Fixed logging of XA commands sent to server, it's now configurable + via "logXaCommands" property (defaults to "false"). + + - Fixed issue where XADataSources couldn't be bound into JNDI, + as the DataSourceFactory didn't know how to create instances + of them. + + - Fixed issue where XADataSources couldn't be bound into JNDI, + as the DataSourceFactory didn't know how to create instances + of them. + + - Usage advisor will now issue warnings for result sets with large numbers + of rows (size configured by "resultSetSizeThreshold" property, default + value is 100). + +10-20-06 - Version 5.0.4 + + - Fixed BUG#21379 - column names don't match metadata in cases + where server doesn't return original column names (column functions) + thus breaking compatibility with applications that expect 1-1 mappings + between findColumn() and rsmd.getColumnName(), usually manifests itself + as "Can't find column ('')" exceptions. + + - Fixed BUG#21544 - When using information_schema for metadata, + COLUMN_SIZE for getColumns() is not clamped to range of + java.lang.Integer as is the case when not using + information_schema, thus leading to a truncation exception that + isn't present when not using information_schema. + + - Fixed configuration property "jdbcCompliantTruncation" was not + being used for reads of result set values. + + - Fixed BUG#22024 - Newlines causing whitespace to span confuse + procedure parser when getting parameter metadata for stored + procedures. + + - Driver now supports {call sp} (without "()" if procedure has no + arguments). + + - Fixed BUG#22359 - Driver was using milliseconds for + Statement.setQueryTimeout() when specification says argument is + to be in seconds. + + - Workaround for server crash when calling stored procedures + via a server-side prepared statement (driver now detects + prepare(stored procedure) and substitutes client-side prepared + statement), addresses BUG#22297. + + - Added new _ci collations to CharsetMapping, fixing + Bug#22456 - utf8_unicode_ci not working. + + - Fixed BUG#22290 - Driver issues truncation on write exception when + it shouldn't (due to sending big decimal incorrectly to server with + server-side prepared statement). + + - Fixed BUG#22613 - DBMD.getColumns() does not return expected + COLUMN_SIZE for the SET type, now returns length of largest possible + set disregarding whitespace or the "," delimitters to be consistent + with the ODBC driver. + + - Driver now sends numeric 1 or 0 for client-prepared statement + setBoolean() calls instead of '1' or '0'. + + - DatabaseMetaData correctly reports true for supportsCatalog*() + methods. + +07-26-06 - Version 5.0.3 + + - Fixed BUG#20650 - Statement.cancel() causes NullPointerException + if underlying connection has been closed due to server failure. + + - Added configuration option "noAccessToProcedureBodies" which will + cause the driver to create basic parameter metadata for + CallableStatements when the user does not have access to procedure + bodies via "SHOW CREATE PROCEDURE" or selecting from mysql.proc + instead of throwing an exception. The default value for this option + is "false". + +07-11-06 - Version 5.0.2-beta (5.0.1 not released due to packaging error) + + - Fixed BUG#17401 - Can't use XAConnection for local transactions when + no global transaction is in progress. + + - Fixed BUG#18086 - Driver fails on non-ASCII platforms. The driver + was assuming that the platform character set would be a superset + of MySQL's "latin1" when doing the handshake for authentication, + and when reading error messages. We now use Cp1252 for all strings + sent to the server during the handshake phase, and a hard-coded mapping + of the "language" server variable to the character set that + is used for error messages. + + - Fixed BUG#19169 - ConnectionProperties (and thus some + subclasses) are not serializable, even though some J2EE containers + expect them to be. + + - Fixed BUG#20242 - MysqlValidConnectionChecker for JBoss doesn't + work with MySQLXADataSources. + + - Better caching of character set converters (per-connection) + to remove a bottleneck for multibyte character sets. + + - Added connection/datasource property "pinGlobalTxToPhysicalConnection" + (defaults to "false"). When set to "true", when using XAConnections, the + driver ensures that operations on a given XID are always routed to the + same physical connection. This allows the XAConnection to support + "XA START ... JOIN" after "XA END" has been called, and is also a + workaround for transaction managers that don't maintain thread affinity + for a global transaction (most either always maintain thread affinity, + or have it as a configuration option). + + - MysqlXaConnection.recover(int flags) now allows combinations of + XAResource.TMSTARTRSCAN and TMENDRSCAN. To simulate the "scanning" + nature of the interface, we return all prepared XIDs for TMSTARTRSCAN, + and no new XIDs for calls with TMNOFLAGS, or TMENDRSCAN when not in + combination with TMSTARTRSCAN. This change was made for API compliance, + as well as integration with IBM WebSphere's transaction manager. + +12-23-05 - Version 5.0.0-beta + + - XADataSource implemented (ported from 3.2 branch which won't be + released as a product). Use + "com.mysql.jdbc.jdbc2.optional.MysqlXADataSource" as your datasource + class name in your application server to utilize XA transactions + in MySQL-5.0.10 and newer. + + - PreparedStatement.setString() didn't work correctly when + sql_mode on server contained NO_BACKSLASH_ESCAPES, and no characters + that needed escaping were present in the string. + + - Attempt detection of the MySQL type "BINARY" (it's an alias, so this isn't + always reliable), and use the java.sql.Types.BINARY type mapping for it. + + - Moved -bin-g.jar file into separate "debug" subdirectory to avoid confusion. + + - Don't allow .setAutoCommit(true), or .commit() or .rollback() on an XA-managed + connection as-per the JDBC specification. + + - If the connection "useTimezone" is set to "true", then also respect timezone + conversions in escape-processed string literals (e.g. "{ts ...}" and + "{t ...}"). + + - Return original column name for RSMD.getColumnName() if the column was aliased, + alias name for .getColumnLabel() (if aliased), and original table name + for .getTableName(). Note this only works for MySQL-4.1 and newer, as + older servers don't make this information available to clients. + + - Setting "useJDBCCompliantTimezoneShift=true" (it's not the default) + causes the driver to use GMT for _all_ TIMESTAMP/DATETIME timezones, + and the current VM timezone for any other type that refers to timezones. + This feature can not be used when "useTimezone=true" to convert between + server and client timezones. + + - Add one level of indirection of internal representation of CallableStatement + parameter metadata to avoid class not found issues on JDK-1.3 for + ParameterMetadata interface (which doesn't exist prior to JDBC-3.0). + + - Added unit tests for XADatasource, as well as friendlier exceptions + for XA failures compared to the "stock" XAException (which has no + messages). + + - Fixed BUG#14279 - Idle timeouts cause XAConnections to whine about rolling + themselves back + + - Added support for Connector/MXJ integration via url subprotocol + "jdbc:mysql:mxj://....". + + - Moved all SQLException constructor usage to a factory in SQLError + (ground-work for JDBC-4.0 SQLState-based exception classes). + + - Removed Java5-specific calls to BigDecimal constructor (when + result set value is '', (int)0 was being used as an argument + in-directly via method return value. This signature doesn't exist + prior to Java5.) + + - Moved all SQLException creation to a factory method in SQLError, + groundwork for JDBC-4.0 SQLState class-based exceptions. + + - Added service-provider entry to META-INF/services/java.sql.Driver + for JDBC-4.0 support. + + - Return "[VAR]BINARY" for RSMD.getColumnTypeName() when that is actually + the type, and it can be distinguished (MySQL-4.1 and newer). + + - When fix for BUG#14562 was merged from 3.1.12, added functionality + for CallableStatement's parameter metadata to return correct + information for .getParameterClassName(). + + - Fuller synchronization of Connection to avoid deadlocks when + using multithreaded frameworks that multithread a single connection + (usually not recommended, but the JDBC spec allows it anyways), + part of fix to BUG#14972). + + - Implementation of Statement.cancel() and Statement.setQueryTimeout(). + Both require MySQL-5.0.0 or newer server, require a separate connection + to issue the "KILL QUERY" command, and in the case of setQueryTimeout() + creates an additional thread to handle the timeout functionality. + + Note: Failures to cancel the statement for setQueryTimeout() may manifest + themselves as RuntimeExceptions rather than failing silently, as there + is currently no way to unblock the thread that is executing the query being + cancelled due to timeout expiration and have it throw the exception + instead. + + - Removed dead code in com.mysql.jdbc.Connection. + + - Made construction of com.mysql.jdbc.Field (result set metadata) + instances more efficient for non-string types by not doing + character set initialization, or detection of type changes due to + temporary tables. + + - Removed redundant code in com.mysql.jdbc.MysqlIO. + + - Removed work done for BUG#14652, and instead loosened synchronization + to solve a number of deadlock issues in BUG#18719, BUG#18367, BUG#17709 + and BUG#15067. New strategy basically makes Connection instances threadsafe + and thus shareable across threads, and anything else threadsafe, but not + necessarily shareable across threads due to JDBC API interactions that + can cause non-obvious behavior and/or deadlock scenarios to occur since + the API is not designed to be used from multiple threads at once. + + Therefore, unless external synchronization is provided, clients should + not allow multiple threads to share a given statement or result set. Examples + of issues with the API itself not being multi-thread suitable include, + but are not limited to race conditions between modifiers and execution and + retrieval methods on statements and result sets that are not synchronizable + such as ResultSet.get*() and traversal methods, or Statement.execute*() closing + result sets without effectively making the driver itself serializable across the + board. + + These changes should not have any effect on "normal" J(2)EE use cases + where only one thread ever uses a connection instance and the objects created by + it. + + - Use a java.util.Timer to schedule cancellation of queries via + Statement.setQueryTimeout() rather than one thread per potential cancellation. + + A new thread will be used to actually cancel a running query, as there's potential + for a cancel request to block other cancel requests if all run from the + same thread. + +nn-nn-07 - Version 3.1.15 + + - Fixed BUG#23281 - Downed slave caused round-robin load balance to + not cycle back to first host in list. + + - Disabled use of server-side prepared statements by default. + + - Handle YYYY-MM-DD hh:mm:ss format of timestamp in + ResultSet.getTimeFromString(). + + - Fixed BUG#24840 - character encoding of "US-ASCII" doesn't map correctly + for 4.1 or newer + + - Added Implementation-Vendor-Id attribute to jar manifest per request + in BUG#15641. + + - C3P0 >= version 0.9.1 passes non-proxied connections to + MysqlConnectionTester, thus it began throwing ClassCastExceptions. + MysqlConnectionTester now checks if it has a plain Connection and uses + that if possible. Thanks to Brian Skrab for the fix. + +10-19-06 - Version 3.1.14 + + - Fixed BUG#20479 - Updatable result set throws ClassCastException + when there is row data and moveToInsertRow() is called. + + - Fixed BUG#20485 - Updatable result set that contains + a BIT column fails when server-side prepared statements are used. + + - Fixed BUG#16987 - Memory leak with profileSQL=true. + + - Fixed BUG#19726 - Connection fails to localhost when using + timeout and IPv6 is configured. + + - Fixed BUG#16791 - NullPointerException in MysqlDataSourceFactory + due to Reference containing RefAddrs with null content. + + - Fixed BUG#20306 - ResultSet.getShort() for UNSIGNED TINYINT + returns incorrect values when using server-side prepared statements. + + - Fixed BUG#20687 - Can't pool server-side prepared statements, exception + raised when re-using them. + + - Fixed BUG#21062 - ResultSet.getSomeInteger() doesn't work for BIT(>1). + + - Fixed BUG#18880 - ResultSet.getFloatFromString() can't retrieve + values near Float.MIN/MAX_VALUE. + + - Fixed BUG#20888 - escape of quotes in client-side prepared + statements parsing not respected. Patch covers more than bug report, + including NO_BACKSLASH_ESCAPES being set, and stacked quote characters + forms of escaping (i.e. '' or ""). + + - Fixed BUG#19993 - ReplicationDriver does not always round-robin load + balance depending on URL used for slaves list. + + - Fixed calling toString() on ResultSetMetaData for driver-generated + (i.e. from DatabaseMetaData method calls, or from getGeneratedKeys()) + result sets would raise a NullPointerException. + + - Fixed Bug#21207 - Driver throws NPE when tracing prepared statements that + have been closed (in asSQL()). + + - Removed logger autodectection altogether, must now specify logger + explitly if you want to use a logger other than one that logs + to STDERR. + + - Fixed BUG#22290 - Driver issues truncation on write exception when + it shouldn't (due to sending big decimal incorrectly to server with + server-side prepared statement). + + - Driver now sends numeric 1 or 0 for client-prepared statement + setBoolean() calls instead of '1' or '0'. + + - Fixed bug where driver would not advance to next host if + roundRobinLoadBalance=true and the last host in the list is down. + + - Fixed BUG#18258 - DatabaseMetaData.getTables(), columns() with bad + catalog parameter threw exception rather than return empty result + set (as required by spec). + + - Check and store value for continueBatchOnError property in constructor + of Statements, rather than when executing batches, so that Connections + closed out from underneath statements don't cause NullPointerExceptions + when it's required to check this property. + + - Fixed bug when calling stored functions, where parameters weren't + numbered correctly (first parameter is now the return value, subsequent + parameters if specified start at index "2"). + + - Fixed BUG#21814 - time values outside valid range silently wrap. + +05-26-06 - Version 3.1.13 + + - Fixed BUG#15464 - INOUT parameter does not store IN value. + + - Fixed BUG#14609 - Exception thrown for new decimal type when + using updatable result sets. + + - Fixed BUG#15544, no "dos" character set in MySQL > 4.1.0 + + - Fixed BUG#15383 - PreparedStatement.setObject() serializes + BigInteger as object, rather than sending as numeric value + (and is thus not complementary to .getObject() on an UNSIGNED + LONG type). + + - Fixed BUG#11874 - ResultSet.getShort() for UNSIGNED TINYINT + returned wrong values. + + - Fixed BUG#15676 - lib-nodist directory missing from + package breaks out-of-box build + + - Fixed BUG#15854 - DBMD.getColumns() returns wrong type for BIT. + + - Fixed BUG#16169 - ResultSet.getNativeShort() causes stack overflow error + via recurisve calls. + + - Fixed BUG#14938 - Unable to initialize character set mapping tables. + Removed reliance on .properties files to hold this information, as it + turns out to be too problematic to code around class loader hierarchies + that change depending on how an application is deployed. Moved information + back into the CharsetMapping class. + + - Fixed BUG#16841 - updatable result set doesn't return AUTO_INCREMENT + values for insertRow() when multiple column primary keys are used. (the + driver was checking for the existence of single-column primary keys and + an autoincrement value > 0 instead of a straightforward isAutoIncrement() + check). + + - Fixed BUG#17099 - Statement.getGeneratedKeys() throws NullPointerException + when no query has been processed. + + - Fixed BUG#13469 - Driver tries to call methods that don't exist on older and + newer versions of Log4j. The fix is not trying to auto-detect presense of log4j, + too many different incompatible versions out there in the wild to do this reliably. + + If you relied on autodetection before, you will need to add + "logger=com.mysql.jdbc.log.Log4JLogger" to your JDBC URL to enable Log4J usage, + or alternatively use the new "CommonsLogger" class to take care of this. + + - Added support for Apache Commons logging, use "com.mysql.jdbc.log.CommonsLogger" + as the value for the "logger" configuration property. + + - LogFactory now prepends "com.mysql.jdbc.log" to log class name if it can't be + found as-specified. This allows you to use "short names" for the built-in log + factories, for example "logger=CommonsLogger" instead of + "logger=com.mysql.jdbc.log.CommonsLogger". + + - Fixed BUG#15570 - ReplicationConnection incorrectly copies state, + doesn't transfer connection context correctly when transitioning between + the same read-only states. + + - Fixed BUG#18041 - Server-side prepared statements don't cause + truncation exceptions to be thrown when truncation happens. + + - Added performance feature, re-writing of batched executes for + Statement.executeBatch() (for all DML statements) and + PreparedStatement.executeBatch() (for INSERTs with VALUE clauses + only). Enable by using "rewriteBatchedStatements=true" in your JDBC URL. + + - Fixed BUG#17898 - registerOutParameter not working when some + parameters pre-populated. Still waiting for feedback from JDBC experts + group to determine what correct parameter count from getMetaData() + should be, however. + + - Fixed BUG#17587 - clearParameters() on a closed prepared statement + causes NPE. + + - Map "latin1" on MySQL server to CP1252 for MySQL > 4.1.0. + + - Added additional accessor and mutator methods on ConnectionProperties + so that DataSource users can use same naming as regular URL properties. + + - Fixed BUG#18740 - Data truncation and getWarnings() only returns last + warning in set. + + - Improved performance of retrieving BigDecimal, Time, Timestamp and Date + values from server-side prepared statements by creating fewer short-lived + instances of Strings when the native type is not an exact match for + the requested type. Fixes BUG#18496 for BigDecimals. + + - Fixed BUG#18554 - Aliased column names where length of name > 251 + are corrupted. + + - Fixed BUG#17450 - ResultSet.wasNull() not always reset + correctly for booleans when done via conversion for server-side + prepared statements. + + - Fixed BUG#16277 - Invalid classname returned for + RSMD.getColumnClassName() for BIGINT type. + + - Fixed case where driver wasn't reading server status correctly when + fetching server-side prepared statement rows, which in some cases + could cause warning counts to be off, or multiple result sets to not + be read off the wire. + + - Driver now aware of fix for BIT type metadata that went into + MySQL-5.0.21 for server not reporting length consistently (bug + number 13601). + + - Fixed BUG#19282 - ResultSet.wasNull() returns incorrect value + when extracting native string from server-side prepared statement + generated result set. + +11-30-05 - Version 3.1.12 + + - Fixed client-side prepared statement bug with embedded ? inside + quoted identifiers (it was recognized as a placeholder, when it + was not). + + - Don't allow executeBatch() for CallableStatements with registered + OUT/INOUT parameters (JDBC compliance). + + - Fall back to platform-encoding for URLDecoder.decode() when + parsing driver URL properties if the platform doesn't have a + two-argument version of this method. + + - Fixed BUG#14562 - Java type conversion may be incorrect for + mediumint. + + - Added configuration property "useGmtMillisForDatetimes" which + when set to true causes ResultSet.getDate(), .getTimestamp() to + return correct millis-since GMT when .getTime() is called on + the return value (currently default is "false" for legacy + behavior). + + - Fixed DatabaseMetaData.stores*Identifiers(): + + * if lower_case_table_names=0 (on server): + + storesLowerCaseIdentifiers() returns false + storesLowerCaseQuotedIdentifiers() returns false + storesMixedCaseIdentifiers() returns true + storesMixedCaseQuotedIdentifiers() returns true + storesUpperCaseIdentifiers() returns false + storesUpperCaseQuotedIdentifiers() returns true + + * if lower_case_table_names=1 (on server): + + storesLowerCaseIdentifiers() returns true + storesLowerCaseQuotedIdentifiers() returns true + storesMixedCaseIdentifiers() returns false + storesMixedCaseQuotedIdentifiers() returns false + storesUpperCaseIdentifiers() returns false + storesUpperCaseQuotedIdentifiers() returns true + + - Fixed BUG#14815 - DatabaseMetaData.getColumns() doesn't + return TABLE_NAME correctly. + + - Fixed BUG#14909 - escape processor replaces quote character + in quoted string with string delimiter. + + - Fixed BUG#12975 - OpenOffice expects + DBMD.supportsIntegrityEnhancementFacility() to return "true" + if foreign keys are supported by the datasource, even though + this method also covers support for check constraints, + which MySQL _doesn't_ have. Setting the configuration property + "overrideSupportsIntegrityEnhancementFacility" to "true" causes + the driver to return "true" for this method. + + - Added "com.mysql.jdbc.testsuite.url.default" system property to + set default JDBC url for testsuite (to speed up bug resolution + when I'm working in Eclipse). + + - Fixed BUG#14938 - Unable to initialize character set mapping + tables (due to J2EE classloader differences). + + - Fixed BUG#14972 - Deadlock while closing server-side prepared + statements from multiple threads sharing one connection. + + - Fixed BUG#12230 - logSlowQueries should give better info. + + - Fixed BUG#13775 - Extraneous sleep on autoReconnect. + + - Fixed BUG#15024 - Driver incorrectly closes streams passed as + arguments to PreparedStatements. Reverts to legacy behavior by + setting the JDBC configuration property "autoClosePStmtStreams" + to "true" (also included in the 3-0-Compat configuration "bundle"). + + - Fixed BUG#13048 - maxQuerySizeToLog is not respected. Added logging of + bound values for execute() phase of server-side prepared statements + when profileSQL=true as well. + + - Fixed BUG#15065 - Usage advisor complains about unreferenced + columns, even though they've been referenced. + + - Don't increase timeout for failover/reconnect (BUG#6577) + + - Process escape tokens in Connection.prepareStatement(...), fix + for BUG#15141. You can disable this behavior by setting + the JDBC URL configuration property "processEscapeCodesForPrepStmts" + to "false". + + - Fixed BUG#13255 - Reconnect during middle of executeBatch() + should not occur if autoReconnect is enabled. + +10-07-05 - Version 3.1.11 + + - Fixed BUG#11629 - Spurious "!" on console when character + encoding is "utf8". + + - Fixed statements generated for testcases missing ";" for + "plain" statements. + + - Fixed BUG#11663 - Incorrect generation of testcase scripts + for server-side prepared statements. + + - Fixed regression caused by fix for BUG#11552 that caused driver + to return incorrect values for unsigned integers when those + integers where within the range of the positive signed type. + + - Moved source code to svn repo. + + - Fixed BUG#11797 - Escape tokenizer doesn't respect stacked single quotes + for escapes. + + - GEOMETRY type not recognized when using server-side prepared statements. + + - Fixed BUG#11879 -- ReplicationConnection won't switch to slave, throws + "Catalog can't be null" exception. + + - Fixed BUG#12218, properties shared between master and slave with + replication connection. + + - Fixed BUG#10630, Statement.getWarnings() fails with NPE if statement + has been closed. + + - Only get char[] from SQL in PreparedStatement.ParseInfo() when needed. + + - Fixed BUG#12104 - Geometry types not handled with server-side prepared + statements. + + - Fixed BUG#11614 - StringUtils.getBytes() doesn't work when using + multibyte character encodings and a length in _characters_ is + specified. + + - Fixed BUG#11798 - Pstmt.setObject(...., Types.BOOLEAN) throws exception. + + - Fixed BUG#11976 - maxPerformance.properties mis-spells + "elideSetAutoCommits". + + - Fixed BUG#11575 -- DBMD.storesLower/Mixed/UpperIdentifiers() + reports incorrect values for servers deployed on Windows. + + - Fixed BUG#11190 - ResultSet.moveToCurrentRow() fails to work when + preceeded by a call to ResultSet.moveToInsertRow(). + + - Fixed BUG#11115, VARBINARY data corrupted when using server-side + prepared statements and .setBytes(). + + - Fixed BUG#12229 - explainSlowQueries hangs with server-side + prepared statements. + + - Fixed BUG#11498 - Escape processor didn't honor strings demarcated + with double quotes. + + - Lifted restriction of changing streaming parameters with server-side + prepared statements. As long as _all_ streaming parameters were set + before execution, .clearParameters() does not have to be called. + (due to limitation of client/server protocol, prepared statements + can not reset _individual_ stream data on the server side). + + - Reworked Field class, *Buffer, and MysqlIO to be aware of field + lengths > Integer.MAX_VALUE. + + - Updated DBMD.supportsCorrelatedQueries() to return true for versions > + 4.1, supportsGroupByUnrelated() to return true and + getResultSetHoldability() to return HOLD_CURSORS_OVER_COMMIT. + + - Fixed BUG#12541 - Handling of catalog argument in + DatabaseMetaData.getIndexInfo(), which also means changes to the following + methods in DatabaseMetaData: + + - getBestRowIdentifier() + - getColumns() + - getCrossReference() + - getExportedKeys() + - getImportedKeys() + - getIndexInfo() + - getPrimaryKeys() + - getProcedures() (and thus indirectly getProcedureColumns()) + - getTables() + + The "catalog" argument in all of these methods now behaves in the following + way: + + - Specifying NULL means that catalog will not be used to filter the + results (thus all databases will be searched), unless you've + set "nullCatalogMeansCurrent=true" in your JDBC URL properties. + + - Specifying "" means "current" catalog, even though this isn't quite + JDBC spec compliant, it's there for legacy users. + + - Specifying a catalog works as stated in the API docs. + + - Made Connection.clientPrepare() available from "wrapped" connections + in the jdbc2.optional package (connections built by + ConnectionPoolDataSource instances). + + - Added Connection.isMasterConnection() for clients to be able to determine + if a multi-host master/slave connection is connected to the first host + in the list. + + - Fixed BUG#12753 - Tokenizer for "=" in URL properties was causing + sessionVariables=.... to be parameterized incorrectly. + + - Fixed BUG#11781, foreign key information that is quoted is + parsed incorrectly when DatabaseMetaData methods use that + information. + + - The "sendBlobChunkSize" property is now clamped to "max_allowed_packet" + with consideration of stream buffer size and packet headers to avoid + PacketTooBigExceptions when "max_allowed_packet" is similar in size + to the default "sendBlobChunkSize" which is 1M. + + - CallableStatement.clearParameters() now clears resources associated + with INOUT/OUTPUT parameters as well as INPUT parameters. + + - Fixed BUG#12417 - Connection.prepareCall() is database name + case-sensitive (on Windows systems). + + - Fixed BUG#12752 - Cp1251 incorrectly mapped to win1251 for + servers newer than 4.0.x. + + - Fixed BUG#12970 - java.sql.Types.OTHER returned for + BINARY and VARBINARY columns when using + DatabaseMetaData.getColumns(). + + - ServerPreparedStatement.getBinding() now checks if the statement + is closed before attempting to reference the list of parameter + bindings, to avoid throwing a NullPointerException. + + - Fixed BUG#13277 - ResultSetMetaData from + Statement.getGeneratedKeys() caused NullPointerExceptions to be + thrown whenever a method that required a connection reference + was called. + + - Removed support for java.nio I/O. Too many implementations + turned out to be buggy, and there was no performance difference + since MySQL is a blocking protocol anyway. + +06-23-05 - Version 3.1.10-stable + + - Fixed connecting without a database specified raised an exception + in MysqlIO.changeDatabaseTo(). + + - Initial implemention of ParameterMetadata for + PreparedStatement.getParameterMetadata(). Only works fully + for CallableStatements, as current server-side prepared statements + return every parameter as a VARCHAR type. + + - Fixed BUG#11552 - Server-side prepared statements return incorrect + values for unsigned TINYINT, SMALLINT, INT and Long. + + - Fixed BUG#11540 - Incorrect year conversion in setDate(..) for + system that use B.E. year in default locale. + +06-22-05 - Version 3.1.9-stable + + - Overhaul of character set configuration, everything now + lives in a properties file. + + - Driver now correctly uses CP932 if available on the server + for Windows-31J, CP932 and MS932 java encoding names, + otherwise it resorts to SJIS, which is only a close + approximation. Currently only MySQL-5.0.3 and newer (and + MySQL-4.1.12 or .13, depending on when the character set + gets backported) can reliably support any variant of CP932. + + - Fixed BUG#9064 - com.mysql.jdbc.PreparedStatement.ParseInfo + does unnecessary call to toCharArray(). + + - Fixed Bug#10144 - Memory leak in ServerPreparedStatement if + serverPrepare() fails. + + - Actually write manifest file to correct place so it ends up + in the binary jar file. + + - Added "createDatabaseIfNotExist" property (default is "false"), + which will cause the driver to ask the server to create the + database specified in the URL if it doesn't exist. You must have + the appropriate privileges for database creation for this to + work. + + - Fixed BUG#10156 - Unsigned SMALLINT treated as signed for ResultSet.getInt(), + fixed all cases for UNSIGNED integer values and server-side prepared statements, + as well as ResultSet.getObject() for UNSIGNED TINYINT. + + - Fixed BUG#10155, double quotes not recognized when parsing + client-side prepared statements. + + - Made enableStreamingResults() visible on + com.mysql.jdbc.jdbc2.optional.StatementWrapper. + + - Made ServerPreparedStatement.asSql() work correctly so auto-explain + functionality would work with server-side prepared statements. + + - Made JDBC2-compliant wrappers public in order to allow access to + vendor extensions. + + - Cleaned up logging of profiler events, moved code to dump a profiler + event as a string to com.mysql.jdbc.log.LogUtils so that third + parties can use it. + + - DatabaseMetaData.supportsMultipleOpenResults() now returns true. The + driver has supported this for some time, DBMD just missed that fact. + + - Fixed BUG#10310 - Driver doesn't support {?=CALL(...)} for calling + stored functions. This involved adding support for function retrieval + to DatabaseMetaData.getProcedures() and getProcedureColumns() as well. + + - Fixed BUG#10485, SQLException thrown when retrieving YEAR(2) + with ResultSet.getString(). The driver will now always treat YEAR types + as java.sql.Dates and return the correct values for getString(). + Alternatively, the "yearIsDateType" connection property can be set to + "false" and the values will be treated as SHORTs. + + - The datatype returned for TINYINT(1) columns when "tinyInt1isBit=true" + (the default) can be switched between Types.BOOLEAN and Types.BIT + using the new configuration property "transformedBitIsBoolean", which + defaults to "false". If set to "false" (the default), + DatabaseMetaData.getColumns() and ResultSetMetaData.getColumnType() + will return Types.BOOLEAN for TINYINT(1) columns. If "true", + Types.BOOLEAN will be returned instead. Irregardless of this configuration + property, if "tinyInt1isBit" is enabled, columns with the type TINYINT(1) + will be returned as java.lang.Boolean instances from + ResultSet.getObject(..), and ResultSetMetaData.getColumnClassName() + will return "java.lang.Boolean". + + - Fixed BUG#10496 - SQLException is thrown when using property + "characterSetResults" with cp932 or eucjpms. + + - Reorganized directory layout, sources now in "src" folder, + don't pollute parent directory when building, now output goes + to "./build", distribution goes to "./dist". + + - Added support/bug hunting feature that generates .sql test + scripts to STDERR when "autoGenerateTestcaseScript" is set + to "true". + + - Fixed BUG#10850 - 0-length streams not sent to server when + using server-side prepared statements. + + - Setting "cachePrepStmts=true" now causes the Connection to also + cache the check the driver performs to determine if a prepared + statement can be server-side or not, as well as caches server-side + prepared statements for the lifetime of a connection. As before, + the "prepStmtCacheSize" parameter controls the size of these + caches. + + - Try to handle OutOfMemoryErrors more gracefully. Although not + much can be done, they will in most cases close the connection + they happened on so that further operations don't run into + a connection in some unknown state. When an OOM has happened, + any further operations on the connection will fail with a + "Connection closed" exception that will also list the OOM exception + as the reason for the implicit connection close event. + + - Don't send COM_RESET_STMT for each execution of a server-side + prepared statement if it isn't required. + + - Driver detects if you're running MySQL-5.0.7 or later, and does + not scan for "LIMIT ?[,?]" in statements being prepared, as the + server supports those types of queries now. + + - Fixed BUG#11115, Varbinary data corrupted when using server-side + prepared statements and ResultSet.getBytes(). + + - Connection.setCatalog() is now aware of the "useLocalSessionState" + configuration property, which when set to true will prevent + the driver from sending "USE ..." to the server if the requested + catalog is the same as the current catalog. + + - Added the following configuration bundles, use one or many via + the "useConfigs" configuration property: + + * maxPerformance -- maximum performance without being reckless + * solarisMaxPerformance -- maximum performance for Solaris, + avoids syscalls where it can + * 3-0-Compat -- Compatibility with Connector/J 3.0.x functionality + + - Added "maintainTimeStats" configuration property (defaults to "true"), + which tells the driver whether or not to keep track of the last query time + and the last successful packet sent to the server's time. If set to + false, removes two syscalls per query. + + - Fixed BUG#11259, autoReconnect ping causes exception on connection + startup. + + - Fixed BUG#11360 Connector/J dumping query into SQLException twice + + - Fixed PreparedStatement.setClob() not accepting null as a parameter. + + - Fixed BUG#11411 - Production package doesn't include JBoss integration + classes. + + - Removed nonsensical "costly type conversion" warnings when using + usage advisor. + +04-14-05 - Version 3.1.8-stable + + - Fixed DatabaseMetaData.getTables() returning views when they were + not asked for as one of the requested table types. + + - Added support for new precision-math DECIMAL type in MySQL >= 5.0.3. + + - Fixed ResultSet.getTime() on a NULL value for server-side prepared + statements throws NPE. + + - Made Connection.ping() a public method. + + - Fixed Bug#8868, DATE_FORMAT() queries returned as BLOBs from getObject(). + + - ServerPreparedStatements now correctly 'stream' BLOB/CLOB data to the + server. You can configure the threshold chunk size using the + JDBC URL property 'blobSendChunkSize' (the default is one megabyte). + + - BlobFromLocator now uses correct identifier quoting when generating + prepared statements. + + - Server-side session variables can be preset at connection time by + passing them as a comma-delimited list for the connection property + 'sessionVariables'. + + - Fixed regression in ping() for users using autoReconnect=true. + + - Fixed BUG#9040 - PreparedStatement.addBatch() doesn't work with server-side + prepared statements and streaming BINARY data. + + - Fixed BUG#8800 - DBMD.supportsMixedCase*Identifiers() returns wrong + value on servers running on case-sensitive filesystems. + + - Fixed BUG#9206, can not use 'UTF-8' for characterSetResults + configuration property. + + - Fixed BUG#9236, a continuation of BUG#8868, where functions used in queries + that should return non-string types when resolved by temporary tables suddenly + become opaque binary strings (work-around for server limitation). Also fixed + fields with type of CHAR(n) CHARACTER SET BINARY to return correct/matching + classes for RSMD.getColumnClassName() and ResultSet.getObject(). + + - Fixed BUG#8792 - DBMD.supportsResultSetConcurrency() not returning + true for forward-only/read-only result sets (we obviously support this). + + - Fixed BUG#8803, 'DATA_TYPE' column from DBMD.getBestRowIdentifier() + causes ArrayIndexOutOfBoundsException when accessed (and in fact, didn't + return any value). + + - Check for empty strings ('') when converting char/varchar column data to numbers, + throw exception if 'emptyStringsConvertToZero' configuration property is set + to 'false' (for backwards-compatibility with 3.0, it is now set to 'true' + by default, but will most likely default to 'false' in 3.2). + + - Fixed BUG#9320 - PreparedStatement.getMetaData() inserts blank row in database + under certain conditions when not using server-side prepared statements. + + - Connection.canHandleAsPreparedStatement() now makes 'best effort' to distinguish + LIMIT clauses with placeholders in them from ones without in order to have fewer + false positives when generating work-arounds for statements the server cannot + currently handle as server-side prepared statements. + + - Fixed build.xml to not compile log4j logging if log4j not available. + + - Added support for the c3p0 connection pool's (http://c3p0.sf.net/) + validation/connection checker interface which uses the lightweight + 'COM_PING' call to the server if available. To use it, configure your + c3p0 connection pool's 'connectionTesterClassName' property to use + 'com.mysql.jdbc.integration.c3p0.MysqlConnectionTester'. + + - Better detection of LIMIT inside/outside of quoted strings so that + the driver can more correctly determine whether a prepared statement + can be prepared on the server or not. + + - Fixed BUG#9319 - Stored procedures with same name in + different databases confuse the driver when it tries to determine + parameter counts/types. + + - Added finalizers to ResultSet and Statement implementations to be JDBC + spec-compliant, which requires that if not explicitly closed, these + resources should be closed upon garbage collection. + + - Fixed BUG#9682 - Stored procedures with DECIMAL parameters with + storage specifications that contained "," in them would fail. + + - PreparedStatement.setObject(int, Object, int type, int scale) now + uses scale value for BigDecimal instances. + + - Fixed BUG#9704 - Statement.getMoreResults() could throw NPE when + existing result set was .close()d. + + - The performance metrics feature now gathers information about + number of tables referenced in a SELECT. + + - The logging system is now automatically configured. If the value has + been set by the user, via the URL property "logger" or the system + property "com.mysql.jdbc.logger", then use that, otherwise, autodetect + it using the following steps: + + Log4j, if it's available, + Then JDK1.4 logging, + Then fallback to our STDERR logging. + + - Fixed BUG#9778, DBMD.getTables() shouldn't return tables if views + are asked for, even if the database version doesn't support views. + + - Fixed driver not returning 'true' for '-1' when ResultSet.getBoolean() + was called on result sets returned from server-side prepared statements. + + - Added a Manifest.MF file with implementation information to the .jar + file. + + - More tests in Field.isOpaqueBinary() to distinguish opaque binary (i.e. + fields with type CHAR(n) and CHARACTER SET BINARY) from output of + various scalar and aggregate functions that return strings. + + - Fixed BUG#9917 - Should accept null for catalog (meaning use current) + in DBMD methods, even though it's not JDBC-compliant for legacy's sake. + Disable by setting connection property "nullCatalogMeansCurrent" to "false" + (which will be the default value in C/J 3.2.x). + + - Fixed BUG#9769 - Should accept null for name patterns in DBMD (meaning "%"), + even though it isn't JDBC compliant, for legacy's sake. Disable by setting + connection property "nullNamePatternMatchesAll" to "false" (which will be + the default value in C/J 3.2.x). + +02-18-05 - Version 3.1.7-stable + + + - Fixed BUG#7686, Timestamp key column data needed "_binary'" + stripped for UpdatableResultSet.refreshRow(). + + - Fixed BUG#7715 - Timestamps converted incorrectly to strings + with Server-side prepared statements and updatable result sets. + + - Detect new sql_mode variable in string form (it used to be + integer) and adjust quoting method for strings appropriately. + + - Added 'holdResultsOpenOverStatementClose' property (default is + false), that keeps result sets open over statement.close() or new + execution on same statement (suggested by Kevin Burton). + + - Fixed BUG#7952 -- Infinite recursion when 'falling back' to master + in failover configuration. + + - Disable multi-statements (if enabled) for MySQL-4.1 versions prior + to version 4.1.10 if the query cache is enabled, as the server + returns wrong results in this configuration. + + - Fixed duplicated code in configureClientCharset() that prevented + useOldUTF8Behavior=true from working properly. + + - Removed 'dontUnpackBinaryResults' functionality, the driver now + always stores results from server-side prepared statements as-is + from the server and unpacks them on demand. + + - Fixed BUG#8096 where emulated locators corrupt binary data + when using server-side prepared statements. + + - Fixed synchronization issue with + ServerPreparedStatement.serverPrepare() that could cause + deadlocks/crashes if connection was shared between threads. + + - By default, the driver now scans SQL you are preparing via all + variants of Connection.prepareStatement() to determine if it is a + supported type of statement to prepare on the server side, and if + it is not supported by the server, it instead prepares it as a + client-side emulated prepared statement (BUG#4718). You can + disable this by passing 'emulateUnsupportedPstmts=false' in your + JDBC URL. + + - Remove _binary introducer from parameters used as in/out + parameters in CallableStatement. + + - Always return byte[]s for output parameters registered as *BINARY. + + - Send correct value for 'boolean' "true" to server for + PreparedStatement.setObject(n, "true", Types.BIT). + + - Fixed bug with Connection not caching statements from + prepareStatement() when the statement wasn't a server-side + prepared statement. + + - Choose correct 'direction' to apply time adjustments when both + client and server are in GMT timezone when using + ResultSet.get(..., cal) and PreparedStatement.set(...., cal). + + - Added 'dontTrackOpenResources' option (default is false, to be + JDBC compliant), which helps with memory use for non-well-behaved + apps (i.e applications which don't close Statements when they + should). + + - Fixed BUG#8428 - ResultSet.getString() doesn't maintain format + stored on server, bug fix only enabled when 'noDatetimeStringSync' + property is set to 'true' (the default is 'false'). + + - Fixed NPE in ResultSet.realClose() when using usage advisor and + result set was already closed. + + - Fixed BUG#8487 - PreparedStatements not creating streaming result + sets. + + - Don't pass NULL to String.valueOf() in + ResultSet.getNativeConvertToString(), as it stringifies it (i.e. + returns "null"), which is not correct for the method in question. + + - Fixed BUG#8484 - ResultSet.getBigDecimal() throws exception + when rounding would need to occur to set scale. The driver now + chooses a rounding mode of 'half up' if non-rounding + BigDecimal.setScale() fails. + + - Added 'useLocalSessionState' configuration property, when set to + 'true' the JDBC driver trusts that the application is well-behaved + and only sets autocommit and transaction isolation levels using + the methods provided on java.sql.Connection, and therefore can + manipulate these values in many cases without incurring + round-trips to the database server. + + - Added enableStreamingResults() to Statement for connection pool + implementations that check Statement.setFetchSize() for + specification-compliant values. Call Statement.setFetchSize(>=0) + to disable the streaming results for that statement. + + - Added support for BIT type in MySQL-5.0.3. The driver will treat + BIT(1-8) as the JDBC standard BIT type (which maps to + java.lang.Boolean), as the server does not currently send enough + information to determine the size of a bitfield when < 9 bits are + declared. BIT(>9) will be treated as VARBINARY, and will return + byte[] when getObject() is called. + +12-23-04 - Version 3.1.6-stable + + - Fixed hang on SocketInputStream.read() with Statement.setMaxRows() and + multiple result sets when driver has to truncate result set directly, + rather than tacking a 'LIMIT n' on the end of it. + + - Fixed BUG#7026 - DBMD.getProcedures() doesn't respect catalog parameter. + + - Respect bytes-per-character for RSMD.getPrecision(). + +12-02-04 - Version 3.1.5-gamma + + - Fix comparisons made between string constants and dynamic strings that + are either toUpperCase()d or toLowerCase()d to use Locale.ENGLISH, as + some locales 'override' case rules for English. Also use + StringUtils.indexOfIgnoreCase() instead of .toUpperCase().indexOf(), + avoids creating a very short-lived transient String instance. + + - Fixed BUG#5235 - Server-side prepared statements did not honor + 'zeroDateTimeBehavior' property, and would cause class-cast + exceptions when using ResultSet.getObject(), as the all-zero string + was always returned. + + - Fixed batched updates with server prepared statements weren't looking if + the types had changed for a given batched set of parameters compared + to the previous set, causing the server to return the error + 'Wrong arguments to mysql_stmt_execute()'. + + - Handle case when string representation of timestamp contains trailing '.' + with no numbers following it. + + - Fixed BUG#5706 - Inefficient detection of pre-existing string instances + in ResultSet.getNativeString(). + + - Don't throw exceptions for Connection.releaseSavepoint(). + + - Use a per-session Calendar instance by default when decoding dates + from ServerPreparedStatements (set to old, less performant behavior by + setting property 'dynamicCalendars=true'). + + - Added experimental configuration property 'dontUnpackBinaryResults', + which delays unpacking binary result set values until they're asked for, + and only creates object instances for non-numerical values (it is set + to 'false' by default). For some usecase/jvm combinations, this is + friendlier on the garbage collector. + + - Fixed BUG#5729 - UNSIGNED BIGINT unpacked incorrectly from + server-side prepared statement result sets. + + - Fixed BUG#6225 - ServerSidePreparedStatement allocating short-lived + objects un-necessarily. + + - Removed un-wanted new Throwable() in ResultSet constructor due to bad + merge (caused a new object instance that was never used for every result + set created) - Found while profiling for BUG#6359. + + - Fixed too-early creation of StringBuffer in EscapeProcessor.escapeSQL(), + also return String when escaping not needed (to avoid unnecssary object + allocations). Found while profiling for BUG#6359. + + - Use null-safe-equals for key comparisons in updatable result sets. + + - Fixed BUG#6537, SUM() on Decimal with server-side prepared statement ignores + scale if zero-padding is needed (this ends up being due to conversion to DOUBLE + by server, which when converted to a string to parse into BigDecimal, loses all + 'padding' zeros). + + - Use DatabaseMetaData.getIdentifierQuoteString() when building DBMD + queries. + + - Use 1MB packet for sending file for LOAD DATA LOCAL INFILE if that + is < 'max_allowed_packet' on server. + + - Fixed BUG#6399, ResultSetMetaData.getColumnDisplaySize() returns incorrect + values for multibyte charsets. + + - Make auto-deserialization of java.lang.Objects stored in BLOBs + configurable via 'autoDeserialize' property (defaults to 'false'). + + - Re-work Field.isOpaqueBinary() to detect 'CHAR(n) CHARACTER SET BINARY' + to support fixed-length binary fields for ResultSet.getObject(). + + - Use our own implementation of buffered input streams to get around + blocking behavior of java.io.BufferedInputStream. Disable this with + 'useReadAheadInput=false'. + + - Fixed BUG#6348, failing to connect to the server when one of the + addresses for the given host name is IPV6 (which the server does + not yet bind on). The driver now loops through _all_ IP addresses + for a given host, and stops on the first one that accepts() a + socket.connect(). + +09-04-04 - Version 3.1.4-beta + + - Fixed BUG#4510 - connector/j 3.1.3 beta does not handle integers + correctly (caused by changes to support unsigned reads in + Buffer.readInt() -> Buffer.readShort()). + + - Added support in DatabaseMetaData.getTables() and getTableTypes() + for VIEWs which are now available in MySQL server version 5.0.x. + + - Fixed BUG#4642 -- ServerPreparedStatement.execute*() sometimes + threw ArrayIndexOutOfBoundsException when unpacking field metadata. + + - Optimized integer number parsing, enable 'old' slower integer parsing + using JDK classes via 'useFastIntParsing=false' property. + + - Added 'useOnlyServerErrorMessages' property, which causes message text + in exceptions generated by the server to only contain the text sent by + the server (as opposed to the SQLState's 'standard' description, followed + by the server's error message). This property is set to 'true' by default. + + - Fixed BUG#4689 - ResultSet.wasNull() does not work for primatives if a + previous null was returned. + + - Track packet sequence numbers if enablePacketDebug=true, and throw an + exception if packets received out-of-order. + + - Fixed BUG#4482, ResultSet.getObject() returns wrong type for strings + when using prepared statements. + + - Calling MysqlPooledConnection.close() twice (even though an application + error), caused NPE. Fixed. + + - Fixed BUG#5012 -- ServerPreparedStatements dealing with return of + DECIMAL type don't work. + + - Fixed BUG#5032 -- ResultSet.getObject() doesn't return + type Boolean for pseudo-bit types from prepared statements on 4.1.x + (shortcut for avoiding extra type conversion when using binary-encoded + result sets obscurred test in getObject() for 'pseudo' bit type) + + - You can now use URLs in 'LOAD DATA LOCAL INFILE' statements, and the + driver will use Java's built-in handlers for retreiving the data and + sending it to the server. This feature is not enabled by default, + you must set the 'allowUrlInLocalInfile' connection property to 'true'. + + - The driver is more strict about truncation of numerics on + ResultSet.get*(), and will throw a SQLException when truncation is + detected. You can disable this by setting 'jdbcCompliantTruncation' to + false (it is enabled by default, as this functionality is required + for JDBC compliance). + + - Added three ways to deal with all-zero datetimes when reading them from + a ResultSet, 'exception' (the default), which throws a SQLException + with a SQLState of 'S1009', 'convertToNull', which returns NULL instead of + the date, and 'round', which rounds the date to the nearest closest value + which is '0001-01-01'. + + - Fixed ServerPreparedStatement to read prepared statement metadata off + the wire, even though it's currently a placeholder instead of using + MysqlIO.clearInputStream() which didn't work at various times because + data wasn't available to read from the server yet. This fixes sporadic + errors users were having with ServerPreparedStatements throwing + ArrayIndexOutOfBoundExceptions. + + - Use com.mysql.jdbc.Message's classloader when loading resource bundle, + should fix sporadic issues when the caller's classloader can't locate + the resource bundle. + +07-07-04 - Version 3.1.3-beta + + - Mangle output parameter names for CallableStatements so they + will not clash with user variable names. + + - Added support for INOUT parameters in CallableStatements. + + - Fix for BUG#4119, null bitmask sent for server-side prepared + statements was incorrect. + + - Use SQL Standard SQL states by default, unless 'useSqlStateCodes' + property is set to 'false'. + + - Added packet debuging code (see the 'enablePacketDebug' property + documentation). + + - Added constants for MySQL error numbers (publicly-accessible, + see com.mysql.jdbc.MysqlErrorNumbers), and the ability to + generate the mappings of vendor error codes to SQLStates + that the driver uses (for documentation purposes). + + - Externalized more messages (on-going effort). + + - Fix for BUG#4311 - Error in retrieval of mediumint column with + prepared statements and binary protocol. + + - Support new timezone variables in MySQL-4.1.3 when + 'useTimezone=true' + + - Support for unsigned numerics as return types from prepared statements. + This also causes a change in ResultSet.getObject() for the 'bigint unsigned' + type, which used to return BigDecimal instances, it now returns instances + of java.lang.BigInteger. + +06-09-04 - Version 3.1.2-alpha + + - Fixed stored procedure parameter parsing info when size was + specified for a parameter (i.e. char(), varchar()). + + - Enabled callable statement caching via 'cacheCallableStmts' + property. + + - Fixed case when no output parameters specified for a + stored procedure caused a bogus query to be issued + to retrieve out parameters, leading to a syntax error + from the server. + + - Fixed case when no parameters could cause a NullPointerException + in CallableStatement.setOutputParameters(). + + - Removed wrapping of exceptions in MysqlIO.changeUser(). + + - Fixed sending of split packets for large queries, enabled nio + ability to send large packets as well. + + - Added .toString() functionality to ServerPreparedStatement, + which should help if you're trying to debug a query that is + a prepared statement (it shows SQL as the server would process). + + - Added 'gatherPerformanceMetrics' property, along with properties + to control when/where this info gets logged (see docs for more + info). + + - ServerPreparedStatements weren't actually de-allocating + server-side resources when .close() was called. + + - Added 'logSlowQueries' property, along with property + 'slowQueriesThresholdMillis' to control when a query should + be considered 'slow'. + + - Correctly map output parameters to position given in + prepareCall() vs. order implied during registerOutParameter() - + fixes BUG#3146. + + - Correctly detect initial character set for servers >= 4.1.0 + + - Cleaned up detection of server properties. + + - Support placeholder for parameter metadata for server >= 4.1.2 + + - Fix for BUG#3539 getProcedures() does not return any procedures in + result set + + - Fix for BUG#3540 getProcedureColumns() doesn't work with wildcards + for procedure name + + - Fixed BUG#3520 -- DBMD.getSQLStateType() returns incorrect value. + + - Added 'connectionCollation' property to cause driver to issue + 'set collation_connection=...' query on connection init if default + collation for given charset is not appropriate. + + - Fixed DatabaseMetaData.getProcedures() when run on MySQL-5.0.0 (output of + 'show procedure status' changed between 5.0.1 and 5.0.0. + + - Fixed BUG#3804 -- getWarnings() returns SQLWarning instead of DataTruncation + + - Don't enable server-side prepared statements for server version 5.0.0 or 5.0.1, + as they aren't compatible with the '4.1.2+' style that the driver uses (the driver + expects information to come back that isn't there, so it hangs). + + +02-14-04 - Version 3.1.1-alpha + + - Fixed bug with UpdatableResultSets not using client-side + prepared statements. + + - Fixed character encoding issues when converting bytes to + ASCII when MySQL doesn't provide the character set, and + the JVM is set to a multibyte encoding (usually affecting + retrieval of numeric values). + + - Unpack 'unknown' data types from server prepared statements + as Strings. + + - Implemented long data (Blobs, Clobs, InputStreams, Readers) + for server prepared statements. + + - Implemented Statement.getWarnings() for MySQL-4.1 and newer + (using 'SHOW WARNINGS'). + + - Default result set type changed to TYPE_FORWARD_ONLY + (JDBC compliance). + + - Centralized setting of result set type and concurrency. + + - Re-factored how connection properties are set and exposed + as DriverPropertyInfo as well as Connection and DataSource + properties. + + - Support for NIO. Use 'useNIO=true' on platforms that support + NIO. + + - Support for SAVEPOINTs (MySQL >= 4.0.14 or 4.1.1). + + - Support for mysql_change_user()...See the changeUser() method + in com.mysql.jdbc.Connection. + + - Reduced number of methods called in average query to be more + efficient. + + - Prepared Statements will be re-prepared on auto-reconnect. Any errors + encountered are postponed until first attempt to re-execute the + re-prepared statement. + + - Ensure that warnings are cleared before executing queries + on prepared statements, as-per JDBC spec (now that we support + warnings). + + - Support 'old' profileSql capitalization in ConnectionProperties. + This property is deprecated, you should use 'profileSQL' if possible. + + - Optimized Buffer.readLenByteArray() to return shared empty byte array + when length is 0. + + - Allow contents of PreparedStatement.setBlob() to be retained + between calls to .execute*(). + + - Deal with 0-length tokens in EscapeProcessor (caused by callable + statement escape syntax). + + - Check for closed connection on delete/update/insert row operations in + UpdatableResultSet. + + - Fix support for table aliases when checking for all primary keys in + UpdatableResultSet. + + - Removed useFastDates connection property. + + - Correctly initialize datasource properties from JNDI Refs, including + explicitly specified URLs. + + - DatabaseMetaData now reports supportsStoredProcedures() for + MySQL versions >= 5.0.0 + + - Fixed stack overflow in Connection.prepareCall() (bad merge). + + - Fixed IllegalAccessError to Calendar.getTimeInMillis() in DateTimeValue + (for JDK < 1.4). + + - Fix for BUG#1673, where DatabaseMetaData.getColumns() is not + returning correct column ordinal info for non '%' column name patterns. + + - Merged fix of datatype mapping from MySQL type 'FLOAT' to + java.sql.Types.REAL from 3.0 branch. + + - Detect collation of column for RSMD.isCaseSensitive(). + + - Fixed sending of queries > 16M. + + - Added named and indexed input/output parameter support to CallableStatement. + MySQL-5.0.x or newer. + + - Fixed NullPointerException in ServerPreparedStatement.setTimestamp(), + as well as year and month descrepencies in + ServerPreparedStatement.setTimestamp(), setDate(). + + - Added ability to have multiple database/JVM targets for compliance + and regression/unit tests in build.xml. + + - Fixed NPE and year/month bad conversions when accessing some + datetime functionality in ServerPreparedStatements and their + resultant result sets. + + - Display where/why a connection was implicitly closed (to + aid debugging). + + - CommunicationsException implemented, that tries to determine + why communications was lost with a server, and displays + possible reasons when .getMessage() is called. + + - Fixed BUG#2359, NULL values for numeric types in binary + encoded result sets causing NullPointerExceptions. + + - Implemented Connection.prepareCall(), and DatabaseMetaData. + getProcedures() and getProcedureColumns(). + + - Reset 'long binary' parameters in ServerPreparedStatement when + clearParameters() is called, by sending COM_RESET_STMT to the + server. + + - Merged prepared statement caching, and .getMetaData() support + from 3.0 branch. + + - Fixed off-by-1900 error in some cases for + years in TimeUtil.fastDate/TimeCreate() when unpacking results + from server-side prepared statements. + + - Fixed BUG#2502 -- charset conversion issue in getTables(). + + - Implemented multiple result sets returned from a statement + or stored procedure. + + - Fixed BUG#2606 -- Server side prepared statements not returning + datatype 'YEAR' correctly. + + - Enabled streaming of result sets from server-side prepared + statements. + + - Fixed BUG#2623 -- Class-cast exception when using + scrolling result sets and server-side prepared statements. + + - Merged unbuffered input code from 3.0. + + - Fixed ConnectionProperties that weren't properly exposed + via accessors, cleaned up ConnectionProperties code. + + - Fixed BUG#2671, NULL fields not being encoded correctly in + all cases in server side prepared statements. + + - Fixed rare buffer underflow when writing numbers into buffers + for sending prepared statement execution requests. + + - Use DocBook version of docs for shipped versions of drivers. + + +02-18-03 - Version 3.1.0-alpha + + - Added 'requireSSL' property. + + - Added 'useServerPrepStmts' property (default 'false'). The + driver will use server-side prepared statements when the + server version supports them (4.1 and newer) when this + property is set to 'true'. It is currently set to 'false' + by default until all bind/fetch functionality has been + implemented. Currently only DML prepared statements are + implemented for 4.1 server-side prepared statements. + + - Track open Statements, close all when Connection.close() + is called (JDBC compliance). + +06-22-05 - Version 3.0.17-ga + + - Fixed BUG#5874, Timestamp/Time conversion goes in the wrong 'direction' + when useTimeZone='true' and server timezone differs from client timezone. + + - Fixed BUG#7081, DatabaseMetaData.getIndexInfo() ignoring 'unique' + parameter. + + - Support new protocol type 'MYSQL_TYPE_VARCHAR'. + + - Added 'useOldUTF8Behavoior' configuration property, which causes + JDBC driver to act like it did with MySQL-4.0.x and earlier when + the character encoding is 'utf-8' when connected to MySQL-4.1 or + newer. + + - Fixed BUG#7316 - Statements created from a pooled connection were + returning physical connection instead of logical connection when + getConnection() was called. + + - Fixed BUG#7033 - PreparedStatements don't encode Big5 (and other + multibyte) character sets correctly in static SQL strings. + + - Fixed BUG#6966, connections starting up failed-over (due to down master) + never retry master. + + - Fixed BUG#7061, PreparedStatement.fixDecimalExponent() adding extra + '+', making number unparseable by MySQL server. + + - Fixed BUG#7686, Timestamp key column data needed "_binary'" stripped for + UpdatableResultSet.refreshRow(). + + - Backported SQLState codes mapping from Connector/J 3.1, enable with + 'useSqlStateCodes=true' as a connection property, it defaults to + 'false' in this release, so that we don't break legacy applications (it + defaults to 'true' starting with Connector/J 3.1). + + - Fixed BUG#7601, PreparedStatement.fixDecimalExponent() adding extra + '+', making number unparseable by MySQL server. + + - Escape sequence {fn convert(..., type)} now supports ODBC-style types + that are prepended by 'SQL_'. + + - Fixed duplicated code in configureClientCharset() that prevented + useOldUTF8Behavior=true from working properly. + + - Handle streaming result sets with > 2 billion rows properly by fixing + wraparound of row number counter. + + - Fixed BUG#7607 - MS932, SHIFT_JIS and Windows_31J not recog. as + aliases for sjis. + + - Fixed BUG#6549 (while fixing #7607), adding 'CP943' to aliases for + sjis. + + - Fixed BUG#8064, which requires hex escaping of binary data when using + multibyte charsets with prepared statements. + + - Fixed BUG#8812, NON_UNIQUE column from DBMD.getIndexInfo() returned + inverted value. + + - Workaround for server BUG#9098 - default values of CURRENT_* for + DATE/TIME/TIMESTAMP/TIMESTAMP columns can't be distinguished from + 'string' values, so UpdatableResultSet.moveToInsertRow() generates + bad SQL for inserting default values. + + - Fixed BUG#8629 - 'EUCKR' charset is sent as 'SET NAMES euc_kr' which + MySQL-4.1 and newer doesn't understand. + + - DatabaseMetaData.supportsSelectForUpdate() returns correct value based + on server version. + + - Use hex escapes for PreparedStatement.setBytes() for double-byte charsets + including 'aliases' Windows-31J, CP934, MS932. + + - Added support for the "EUC_JP_Solaris" character encoding, which maps + to a MySQL encoding of "eucjpms" (backported from 3.1 branch). This only + works on servers that support eucjpms, namely 5.0.3 or later. + +11-15-04 - Version 3.0.16-ga + + - Re-issue character set configuration commands when re-using pooled + connections and/or Connection.changeUser() when connected to MySQL-4.1 + or newer. + + - Fixed ResultSetMetaData.isReadOnly() to detect non-writable columns + when connected to MySQL-4.1 or newer, based on existence of 'original' + table and column names. + + - Fixed BUG#5664, ResultSet.updateByte() when on insert row + throws ArrayOutOfBoundsException. + + - Fixed DatabaseMetaData.getTypes() returning incorrect (i.e. non-negative) + scale for the 'NUMERIC' type. + + - Fixed BUG#6198, off-by-one bug in Buffer.readString(string). + + - Made TINYINT(1) -> BIT/Boolean conversion configurable via 'tinyInt1isBit' + property (default 'true' to be JDBC compliant out of the box). + + - Only set 'character_set_results' during connection establishment if + server version >= 4.1.1. + + - Fixed regression where useUnbufferedInput was defaulting to 'false'. + + - Fixed BUG#6231, ResultSet.getTimestamp() on a column with TIME in it + fails. + +09-04-04 - Version 3.0.15-ga + + - Fixed BUG#4010 - StringUtils.escapeEasternUnicodeByteStream is still + broken for GBK + + - Fixed BUG#4334 - Failover for autoReconnect not using port #'s for any + hosts, and not retrying all hosts. (WARN: This required a change to + the SocketFactory connect() method signature, which is now + + public Socket connect(String host, int portNumber, Properties props), + + therefore any third-party socket factories will have to be changed + to support this signature. + + - Logical connections created by MysqlConnectionPoolDataSource will + now issue a rollback() when they are closed and sent back to the pool. + If your application server/connection pool already does this for you, you + can set the 'rollbackOnPooledClose' property to false to avoid the + overhead of an extra rollback(). + + - Removed redundant calls to checkRowPos() in ResultSet. + + - Fixed BUG#4742, 'DOUBLE' mapped twice in DBMD.getTypeInfo(). + + - Added FLOSS license exemption. + + - Fixed BUG#4808, calling .close() twice on a PooledConnection causes NPE. + + - Fixed BUG#4138 and BUG#4860, DBMD.getColumns() returns incorrect JDBC + type for unsigned columns. This affects type mappings for all numeric + types in the RSMD.getColumnType() and RSMD.getColumnTypeNames() methods + as well, to ensure that 'like' types from DBMD.getColumns() match up + with what RSMD.getColumnType() and getColumnTypeNames() return. + + - 'Production' - 'GA' in naming scheme of distributions. + + - Fix for BUG#4880, RSMD.getPrecision() returning 0 for non-numeric types + (should return max length in chars for non-binary types, max length + in bytes for binary types). This fix also fixes mapping of + RSMD.getColumnType() and RSMD.getColumnTypeName() for the BLOB types based + on the length sent from the server (the server doesn't distinguish between + TINYBLOB, BLOB, MEDIUMBLOB or LONGBLOB at the network protocol level). + + - Fixed BUG#5022 - ResultSet should release Field[] instance in .close(). + + - Fixed BUG#5069 -- ResultSet.getMetaData() should not return + incorrectly-initialized metadata if the result set has been closed, but + should instead throw a SQLException. Also fixed for getRow() and + getWarnings() and traversal methods by calling checkClosed() before + operating on instance-level fields that are nullified during .close(). + + - Parse new timezone variables from 4.1.x servers. + + - Use _binary introducer for PreparedStatement.setBytes() and + set*Stream() when connected to MySQL-4.1.x or newer to avoid + misinterpretation during character conversion. + +05-28-04 - Version 3.0.14-production + + - Fixed URL parsing error + +05-27-04 - Version 3.0.13-production + + - Fixed BUG#3848 - Using a MySQLDatasource without server name fails + + - Fixed BUG#3920 - "No Database Selected" when using + MysqlConnectionPoolDataSource. + + - Fixed BUG#3873 - PreparedStatement.getGeneratedKeys() method returns only + 1 result for batched insertions + +05-18-04 - Version 3.0.12-production + + - Add unsigned attribute to DatabaseMetaData.getColumns() output + in the TYPE_NAME column. + + - Added 'failOverReadOnly' property, to allow end-user to configure + state of connection (read-only/writable) when failed over. + + - Backported 'change user' and 'reset server state' functionality + from 3.1 branch, to allow clients of MysqlConnectionPoolDataSource + to reset server state on getConnection() on a pooled connection. + + - Don't escape SJIS/GBK/BIG5 when using MySQL-4.1 or newer. + + - Allow 'url' parameter for MysqlDataSource and MysqlConnectionPool + DataSource so that passing of other properties is possible from + inside appservers. + + - Map duplicate key and foreign key errors to SQLState of + '23000'. + + - Backport documentation tooling from 3.1 branch. + + - Return creating statement for ResultSets created by + getGeneratedKeys() (BUG#2957) + + - Allow java.util.Date to be sent in as parameter to + PreparedStatement.setObject(), converting it to a Timestamp + to maintain full precision (BUG#3103). + + - Don't truncate BLOBs/CLOBs when using setBytes() and/or + setBinary/CharacterStream() (BUG#2670). + + - Dynamically configure character set mappings for field-level + character sets on MySQL-4.1.0 and newer using 'SHOW COLLATION' + when connecting. + + - Map 'binary' character set to 'US-ASCII' to support DATETIME + charset recognition for servers >= 4.1.2 + + - Use 'SET character_set_results" during initialization to allow any + charset to be returned to the driver for result sets. + + - Use charsetnr returned during connect to encode queries before + issuing 'SET NAMES' on MySQL >= 4.1.0. + + - Add helper methods to ResultSetMetaData (getColumnCharacterEncoding() + and getColumnCharacterSet()) to allow end-users to see what charset + the driver thinks it should be using for the column. + + - Only set character_set_results for MySQL >= 4.1.0. + + - Fixed BUG#3511, StringUtils.escapeSJISByteStream() not covering all + eastern double-byte charsets correctly. + + - Renamed StringUtils.escapeSJISByteStream() to more appropriate + escapeEasternUnicodeByteStream(). + + - Fixed BUG#3554 - Not specifying database in URL caused MalformedURL + exception. + + - Auto-convert MySQL encoding names to Java encoding names if used + for characterEncoding property. + + - Added encoding names that are recognized on some JVMs to fix case + where they were reverse-mapped to MySQL encoding names incorrectly. + + - Use junit.textui.TestRunner for all unit tests (to allow them to be + run from the command line outside of Ant or Eclipse). + + - Fixed BUG#3557 - UpdatableResultSet not picking up default values + for moveToInsertRow(). + + - Fixed BUG#3570 - inconsistent reporting of column type. The server + still doesn't return all types for *BLOBs *TEXT correctly, so the + driver won't return those correctly. + + - Fixed BUG#3520 -- DBMD.getSQLStateType() returns incorrect value. + + - Fixed regression in PreparedStatement.setString() and eastern character + encodings. + + - Made StringRegressionTest 4.1-unicode aware. + +02-19-04 - Version 3.0.11-stable + + - Trigger a 'SET NAMES utf8' when encoding is forced to 'utf8' _or_ + 'utf-8' via the 'characterEncoding' property. Previously, only the + Java-style encoding name of 'utf-8' would trigger this. + + - AutoReconnect time was growing faster than exponentially (BUG#2447). + + - Fixed failover always going to last host in list (BUG#2578) + + - Added 'useUnbufferedInput' parameter, and now use it by default + (due to JVM issue + http://developer.java.sun.com/developer/bugParade/bugs/4401235.html) + + - Detect 'on/off' or '1','2','3' form of lower_case_table_names on + server. + + - Return 'java.lang.Integer' for TINYINT and SMALLINT types from + ResultSetMetaData.getColumnClassName() (fix for BUG#2852). + + - Return 'java.lang.Double' for FLOAT type from ResultSetMetaData. + getColumnClassName() (fix for BUG#2855). + + - Return '[B' instead of java.lang.Object for BINARY, VARBINARY and + LONGVARBINARY types from ResultSetMetaData.getColumnClassName() + (JDBC compliance). + +01-13-04 - Version 3.0.10-stable + + - Don't count quoted id's when inside a 'string' in PreparedStatement + parsing (fix for BUG#1511). + + - 'Friendlier' exception message for PacketTooLargeException + (BUG#1534). + + - Backported fix for aliased tables and UpdatableResultSets in + checkUpdatability() method from 3.1 branch. + + - Fix for ArrayIndexOutOfBounds exception when using Statement.setMaxRows() + (BUG#1695). + + - Fixed BUG#1576, dealing with large blobs and split packets not being + read correctly. + + - Fixed regression of Statement.getGeneratedKeys() and REPLACE statements. + + - Fixed BUG#1630, subsequent call to ResultSet.updateFoo() causes NPE if + result set is not updatable. + + - Fix for 4.1.1-style auth with no password. + + - Fix for BUG#1731, Foreign Keys column sequence is not consistent in + DatabaseMetaData.getImported/Exported/CrossReference(). + + - Fix for BUG#1775 - DatabaseMetaData.getSystemFunction() returning + bad function 'VResultsSion'. + + - Fix for BUG#1592 -- cross-database updatable result sets + are not checked for updatability correctly. + + - DatabaseMetaData.getColumns() should return Types.LONGVARCHAR for + MySQL LONGTEXT type. + + - ResultSet.getObject() on TINYINT and SMALLINT columns should return + Java type 'Integer' (BUG#1913) + + - Added 'alwaysClearStream' connection property, which causes the driver + to always empty any remaining data on the input stream before + each query. + + - Added more descriptive error message 'Server Configuration Denies + Access to DataSource', as well as retrieval of message from server. + + - Autoreconnect code didn't set catalog upon reconnect if it had been + changed. + + - Implement ResultSet.updateClob(). + + - ResultSetMetaData.isCaseSensitive() returned wrong value for CHAR/VARCHAR + columns. + + - Fix for BUG#1933 -- Connection property "maxRows" not honored. + + - Fix for BUG#1925 -- Statements being created too many times in + DBMD.extractForeignKeyFromCreateTable(). + + - Fix for BUG#1914 -- Support escape sequence {fn convert ... } + + - Fix for BUG#1958 -- ArrayIndexOutOfBounds when parameter number == + number of parameters + 1. + + - Fix for BUG#2006 -- ResultSet.findColumn() should use first matching + column name when there are duplicate column names in SELECT query + (JDBC-compliance). + + - Removed static synchronization bottleneck from + PreparedStatement.setTimestamp(). + + - Removed static synchronization bottleneck from instance factory + method of SingleByteCharsetConverter. + + - Enable caching of the parsing stage of prepared statements via + the 'cachePrepStmts', 'prepStmtCacheSize' and 'prepStmtCacheSqlLimit' + properties (disabled by default). + + - Speed up parsing of PreparedStatements, try to use one-pass whenever + possible. + + - Fixed security exception when used in Applets (applets can't + read the system property 'file.encoding' which is needed + for LOAD DATA LOCAL INFILE). + + - Use constants for SQLStates. + + - Map charset 'ko18_ru' to 'ko18r' when connected to MySQL-4.1.0 or + newer. + + - Ensure that Buffer.writeString() saves room for the \0. + + - Fixed exception 'Unknown character set 'danish' on connect w/ JDK-1.4.0 + + - Fixed mappings in SQLError to report deadlocks with SQLStates of '41000'. + + - 'maxRows' property would affect internal statements, so check it for all + statement creation internal to the driver, and set to 0 when it is not. + +10-07-03 - Version 3.0.9-stable + + - Faster date handling code in ResultSet and PreparedStatement (no longer + uses Date methods that synchronize on static calendars). + + - Fixed test for end of buffer in Buffer.readString(). + + - Fixed ResultSet.previous() behavior to move current + position to before result set when on first row + of result set (bugs.mysql.com BUG#496) + + - Fixed Statement and PreparedStatement issuing bogus queries + when setMaxRows() had been used and a LIMIT clause was present + in the query. + + - Fixed BUG#661 - refreshRow didn't work when primary key values + contained values that needed to be escaped (they ended up being + doubly-escaped). + + - Support InnoDB contraint names when extracting foreign key info + in DatabaseMetaData BUG#517 and BUG#664 + (impl. ideas from Parwinder Sekhon) + + - Backported 4.1 protocol changes from 3.1 branch (server-side SQL + states, new field info, larger client capability flags, + connect-with-database, etc). + + - Fix UpdatableResultSet to return values for getXXX() when on + insert row (BUG#675). + + - The insertRow in an UpdatableResultSet is now loaded with + the default column values when moveToInsertRow() is called + (BUG#688) + + - DatabaseMetaData.getColumns() wasn't returning NULL for + default values that are specified as NULL. + + - Change default statement type/concurrency to TYPE_FORWARD_ONLY + and CONCUR_READ_ONLY (spec compliance). + + - Don't try and reset isolation level on reconnect if MySQL doesn't + support them. + + - Don't wrap SQLExceptions in RowDataDynamic. + + - Don't change timestamp TZ twice if useTimezone==true (BUG#774) + + - Fixed regression in large split-packet handling (BUG#848). + + - Better diagnostic error messages in exceptions for 'streaming' + result sets. + + - Issue exception on ResultSet.getXXX() on empty result set (wasn't + caught in some cases). + + - Don't hide messages from exceptions thrown in I/O layers. + + - Don't fire connection closed events when closing pooled connections, or + on PooledConnection.getConnection() with already open connections (BUG#884). + + - Clip +/- INF (to smallest and largest representative values for the type in + MySQL) and NaN (to 0) for setDouble/setFloat(), and issue a warning on the + statement when the server does not support +/- INF or NaN. + + - Fix for BUG#879, double-escaping of '\' when charset is SJIS or GBK and '\' + appears in non-escaped input. + + - When emptying input stream of unused rows for 'streaming' result sets, + have the current thread yield() every 100 rows in order to not monopolize + CPU time. + + - Fixed BUG#1099, DatabaseMetaData.getColumns() getting confused about the + keyword 'set' in character columns. + + - Fixed deadlock issue with Statement.setMaxRows(). + + - Fixed CLOB.truncate(), BUG#1130 + + - Optimized CLOB.setChracterStream(), BUG#1131 + + - Made databaseName, portNumber and serverName optional parameters + for MysqlDataSourceFactory (BUG#1246) + + - Fix for BUG#1247 -- ResultSet.get/setString mashing char 127 + + - Backported auth. changes for 4.1.1 and newer from 3.1 branch. + + - Added com.mysql.jdbc.util.BaseBugReport to help creation of testcases + for bug reports. + + - Added property to 'clobber' streaming results, by setting the + 'clobberStreamingResults' property to 'true' (the default is 'false'). + This will cause a 'streaming' ResultSet to be automatically + closed, and any oustanding data still streaming from the server to + be discarded if another query is executed before all the data has been + read from the server. + +05-23-03 - Version 3.0.8-stable + + - Allow bogus URLs in Driver.getPropertyInfo(). + + - Return list of generated keys when using multi-value INSERTS + with Statement.getGeneratedKeys(). + + - Use JVM charset with filenames and 'LOAD DATA [LOCAL] INFILE' + + - Fix infinite loop with Connection.cleanup(). + + - Changed Ant target 'compile-core' to 'compile-driver', and + made testsuite compilation a separate target. + + - Fixed result set not getting set for Statement.executeUpdate(), + which affected getGeneratedKeys() and getUpdateCount() in + some cases. + + - Unicode character 0xFFFF in a string would cause the driver to + throw an ArrayOutOfBoundsException (Bug #378) + + - Return correct amount of generated keys when using 'REPLACE' + statements. + + - Fix problem detecting server character set in some cases. + + - Fix row data decoding error when using _very_ large packets. + + - Optimized row data decoding. + + - Issue exception when operating on an already-closed + prepared statement. + + - Fixed SJIS encoding bug, thanks to Naoto Sato. + + - Optimized usage of EscapeProcessor. + + - Allow multiple calls to Statement.close() + +04-08-03 - Version 3.0.7-stable + + - Fixed MysqlPooledConnection.close() calling wrong event type. + + - Fixed StringIndexOutOfBoundsException in PreparedStatement. + setClob(). + + - 4.1 Column Metadata fixes + + - Remove synchronization from Driver.connect() and + Driver.acceptsUrl(). + + - IOExceptions during a transaction now cause the Connection to + be closed. + + - Fixed missing conversion for 'YEAR' type in ResultSetMetaData. + getColumnTypeName(). + + - Don't pick up indexes that start with 'pri' as primary keys + for DBMD.getPrimaryKeys(). + + - Throw SQLExceptions when trying to do operations on a forcefully + closed Connection (i.e. when a communication link failure occurs). + + - You can now toggle profiling on/off using + Connection.setProfileSql(boolean). + + - Fixed charset issues with database metadata (charset was not + getting set correctly). + + - Updatable ResultSets can now be created for aliased tables/columns + when connected to MySQL-4.1 or newer. + + - Fixed 'LOAD DATA LOCAL INFILE' bug when file > max_allowed_packet. + + - Fixed escaping of 0x5c ('\') character for GBK and Big5 charsets. + + - Fixed ResultSet.getTimestamp() when underlying field is of type DATE. + + - Ensure that packet size from alignPacketSize() does not + exceed MAX_ALLOWED_PACKET (JVM bug) + + - Don't reset Connection.isReadOnly() when autoReconnecting. + +02-18-03 - Version 3.0.6-stable + + - Fixed ResultSetMetaData to return "" when catalog not known. + Fixes NullPointerExceptions with Sun's CachedRowSet. + + - Fixed DBMD.getTypeInfo() and DBMD.getColumns() returning + different value for precision in TEXT/BLOB types. + + - Allow ignoring of warning for 'non transactional tables' during + rollback (compliance/usability) by setting 'ignoreNonTxTables' + property to 'true'. + + - Fixed SQLExceptions getting swallowed on initial connect. + + - Fixed Statement.setMaxRows() to stop sending 'LIMIT' type queries + when not needed (performance) + + - Clean up Statement query/method mismatch tests (i.e. INSERT not + allowed with .executeQuery()). + + - More checks added in ResultSet traversal method to catch + when in closed state. + + - Fixed ResultSetMetaData.isWritable() to return correct value. + + - Add 'window' of different NULL sorting behavior to + DBMD.nullsAreSortedAtStart (4.0.2 to 4.0.10, true, otherwise, + no). + + - Implemented Blob.setBytes(). You still need to pass the + resultant Blob back into an updatable ResultSet or + PreparedStatement to persist the changes, as MySQL does + not support 'locators'. + + - Backported 4.1 charset field info changes from Connector/J 3.1 + +01-22-03 - Version 3.0.5-gamma + + - Fixed Buffer.fastSkipLenString() causing ArrayIndexOutOfBounds + exceptions with some queries when unpacking fields. + + - Implemented an empty TypeMap for Connection.getTypeMap() so that + some third-party apps work with MySQL (IBM WebSphere 5.0 Connection + pool). + + - Added missing LONGTEXT type to DBMD.getColumns(). + + - Retrieve TX_ISOLATION from database for + Connection.getTransactionIsolation() when the MySQL version + supports it, instead of an instance variable. + + - Quote table names in DatabaseMetaData.getColumns(), + getPrimaryKeys(), getIndexInfo(), getBestRowIdentifier() + + - Greatly reduce memory required for setBinaryStream() in + PreparedStatements. + + - Fixed ResultSet.isBeforeFirst() for empty result sets. + + - Added update options for foreign key metadata. + + +01-06-03 - Version 3.0.4-gamma + + - Added quoted identifiers to database names for + Connection.setCatalog. + + - Added support for quoted identifiers in PreparedStatement + parser. + + - Streamlined character conversion and byte[] handling in + PreparedStatements for setByte(). + + - Reduce memory footprint of PreparedStatements by sharing + outbound packet with MysqlIO. + + - Added 'strictUpdates' property to allow control of amount + of checking for 'correctness' of updatable result sets. Set this + to 'false' if you want faster updatable result sets and you know + that you create them from SELECTs on tables with primary keys and + that you have selected all primary keys in your query. + + - Added support for 4.0.8-style large packets. + + - Fixed PreparedStatement.executeBatch() parameter overwriting. + +12-17-02 - Version 3.0.3-dev + + - Changed charsToByte in SingleByteCharConverter to be non-static + + - Changed SingleByteCharConverter to use lazy initialization of each + converter. + + - Fixed charset handling in Fields.java + + - Implemented Connection.nativeSQL() + + - More robust escape tokenizer -- recognize '--' comments, and allow + nested escape sequences (see testsuite.EscapeProcessingTest) + + - DBMD.getImported/ExportedKeys() now handles multiple foreign keys + per table. + + - Fixed ResultSetMetaData.getPrecision() returning incorrect values + for some floating point types. + + - Fixed ResultSetMetaData.getColumnTypeName() returning BLOB for + TEXT and TEXT for BLOB types. + + - Fixed Buffer.isLastDataPacket() for 4.1 and newer servers. + + - Added CLIENT_LONG_FLAG to be able to get more column flags + (isAutoIncrement() being the most important) + + - Because of above, implemented ResultSetMetaData.isAutoIncrement() + to use Field.isAutoIncrement(). + + - Honor 'lower_case_table_names' when enabled in the server when + doing table name comparisons in DatabaseMetaData methods. + + - Some MySQL-4.1 protocol support (extended field info from selects) + + - Use non-aliased table/column names and database names to fullly + qualify tables and columns in UpdatableResultSet (requires + MySQL-4.1 or newer) + + - Allow user to alter behavior of Statement/ + PreparedStatement.executeBatch() via 'continueBatchOnError' property + (defaults to 'true'). + + - Check for connection closed in more Connection methods + (createStatement, prepareStatement, setTransactionIsolation, + setAutoCommit). + + - More robust implementation of updatable result sets. Checks that + _all_ primary keys of the table have been selected. + + - 'LOAD DATA LOCAL INFILE ...' now works, if your server is configured + to allow it. Can be turned off with the 'allowLoadLocalInfile' + property (see the README). + + - Substitute '?' for unknown character conversions in single-byte + character sets instead of '\0'. + + - NamedPipeSocketFactory now works (only intended for Windows), see + README for instructions. + +11-08-02 - Version 3.0.2-dev + + - Fixed issue with updatable result sets and PreparedStatements not + working + + - Fixed ResultSet.setFetchDirection(FETCH_UNKNOWN) + + - Fixed issue when calling Statement.setFetchSize() when using + arbitrary values + + - Fixed incorrect conversion in ResultSet.getLong() + + - Implemented ResultSet.updateBlob(). + + - Removed duplicate code from UpdatableResultSet (it can be inherited + from ResultSet, the extra code for each method to handle updatability + I thought might someday be necessary has not been needed). + + - Fixed "UnsupportedEncodingException" thrown when "forcing" a + character encoding via properties. + + - Fixed various non-ASCII character encoding issues. + + - Added driver property 'useHostsInPrivileges'. Defaults to true. + Affects whether or not '@hostname' will be used in + DBMD.getColumn/TablePrivileges. + + - All DBMD result set columns describing schemas now return NULL + to be more compliant with the behavior of other JDBC drivers + for other databases (MySQL does not support schemas). + + - Added SSL support. See README for information on how to use it. + + - Properly restore connection properties when autoReconnecting + or failing-over, including autoCommit state, and isolation level. + + - Use 'SHOW CREATE TABLE' when possible for determining foreign key + information for DatabaseMetaData...also allows cascade options for + DELETE information to be returned + + - Escape 0x5c character in strings for the SJIS charset. + + - Fixed start position off-by-1 error in Clob.getSubString() + + - Implemented Clob.truncate() + + - Implemented Clob.setString() + + - Implemented Clob.setAsciiStream() + + - Implemented Clob.setCharacterStream() + + - Added com.mysql.jdbc.MiniAdmin class, which allows you to send + 'shutdown' command to MySQL server...Intended to be used when 'embedding' + Java and MySQL server together in an end-user application. + + - Added 'connectTimeout' parameter that allows users of JDK-1.4 and newer + to specify a maxium time to wait to establish a connection. + + - Failover and autoReconnect only work when the connection is in a + autoCommit(false) state, in order to stay transaction safe + + - Added 'queriesBeforeRetryMaster' property that specifies how many + queries to issue when failed over before attempting to reconnect + to the master (defaults to 50) + + - Fixed DBMD.supportsResultSetConcurrency() so that it returns true + for ResultSet.TYPE_SCROLL_INSENSITIVE and ResultSet.CONCUR_READ_ONLY or + ResultSet.CONCUR_UPDATABLE + + - Fixed ResultSet.isLast() for empty result sets (should return false). + + - PreparedStatement now honors stream lengths in setBinary/Ascii/Character + Stream() unless you set the connection property + 'useStreamLengthsInPrepStmts' to 'false'. + + - Removed some not-needed temporary object creation by using Strings + smarter in EscapeProcessor, Connection and DatabaseMetaData classes. + +09-21-02 - Version 3.0.1-dev + + - Fixed ResultSet.getRow() off-by-one bug. + + - Fixed RowDataStatic.getAt() off-by-one bug. + + - Added limited Clob functionality (ResultSet.getClob(), + PreparedStatemtent.setClob(), + PreparedStatement.setObject(Clob). + + - Added socketTimeout parameter to URL. + + - Connection.isClosed() no longer "pings" the server. + + - Connection.close() issues rollback() when getAutoCommit() == false + + - Added "paranoid" parameter...sanitizes error messages removing + "sensitive" information from them (i.e. hostnames, ports, + usernames, etc.), as well as clearing "sensitive" data structures + when possible. + + - Fixed ResultSetMetaData.isSigned() for TINYINT and BIGINT. + + - Charsets now automatically detected. Optimized code for single-byte + character set conversion. + + - Implemented ResultSet.getCharacterStream() + + - Added "LOCAL TEMPORARY" to table types in DatabaseMetaData.getTableTypes() + + - Massive code clean-up to follow Java coding conventions (the time had come) + + +07-31-02 - Version 3.0.0-dev + + - !!! LICENSE CHANGE !!! The driver is now GPL. If you need + non-GPL licenses, please contact me + + - JDBC-3.0 functionality including + Statement/PreparedStatement.getGeneratedKeys() and + ResultSet.getURL() + + - Performance enchancements - driver is now 50-100% faster + in most situations, and creates fewer temporary objects + + - Repackaging...new driver name is "com.mysql.jdbc.Driver", + old name still works, though (the driver is now provided + by MySQL-AB) + + - Better checking for closed connections in Statement + and PreparedStatement. + + - Support for streaming (row-by-row) result sets (see README) + Thanks to Doron. + + - Support for large packets (new addition to MySQL-4.0 protocol), + see README for more information. + + - JDBC Compliance -- Passes all tests besides stored procedure tests + + + - Fix and sort primary key names in DBMetaData (SF bugs 582086 and 582086) + + - Float types now reported as java.sql.Types.FLOAT (SF bug 579573) + + - ResultSet.getTimestamp() now works for DATE types (SF bug 559134) + + - ResultSet.getDate/Time/Timestamp now recognizes all forms of invalid + values that have been set to all zeroes by MySQL (SF bug 586058) + + - Testsuite now uses Junit (which you can get from www.junit.org) + + - The driver now only works with JDK-1.2 or newer. + + - Added multi-host failover support (see README) + + - General source-code cleanup. + + - Overall speed improvements via controlling transient object + creation in MysqlIO class when reading packets + + - Performance improvements in string handling and field + metadata creation (lazily instantiated) contributed by + Alex Twisleton-Wykeham-Fiennes + + +05-16-02 - Version 2.0.14 + + - More code cleanup + + - PreparedStatement now releases resources on .close() (SF bug 553268) + + - Quoted identifiers not used if server version does not support them. Also, + if server started with --ansi or --sql-mode=ANSI_QUOTES then '"' will be + used as an identifier quote, otherwise '`' will be used. + + - ResultSet.getDouble() now uses code built into JDK to be more precise (but slower) + + - LogicalHandle.isClosed() calls through to physical connection + + - Added SQL profiling (to STDERR). Set "profileSql=true" in your JDBC url. + See README for more information. + + - Fixed typo for relaxAutoCommit parameter. + +04-24-02 - Version 2.0.13 + + - More code cleanup. + + - Fixed unicode chars being read incorrectly (SF bug 541088) + + - Faster blob escaping for PrepStmt + + - Added set/getPortNumber() to DataSource(s) (SF bug 548167) + + - Added setURL() to MySQLXADataSource (SF bug 546019) + + - PreparedStatement.toString() fixed (SF bug 534026) + + - ResultSetMetaData.getColumnClassName() now implemented + + - Rudimentary version of Statement.getGeneratedKeys() from JDBC-3.0 + now implemented (you need to be using JDK-1.4 for this to work, I + believe) + + - DBMetaData.getIndexInfo() - bad PAGES fixed (SF BUG 542201) + +04-07-02 - Version 2.0.12 + + - General code cleanup. + + - Added getIdleFor() method to Connection and MysqlLogicalHandle. + + - Relaxed synchronization in all classes, should fix 520615 and 520393. + + - Added getTable/ColumnPrivileges() to DBMD (fixes 484502). + + - Added new types to getTypeInfo(), fixed existing types thanks to + Al Davis and Kid Kalanon. + + - Added support for BIT types (51870) to PreparedStatement. + + - Fixed getRow() bug (527165) in ResultSet + + - Fixes for ResultSet updatability in PreparedStatement. + - Fixed timezone off by 1-hour bug in PreparedStatement (538286, 528785). + + - ResultSet: Fixed updatability (values being set to null + if not updated). + + - DataSources - fixed setUrl bug (511614, 525565), + wrong datasource class name (532816, 528767) + + - Added identifier quoting to all DatabaseMetaData methods + that need them (should fix 518108) + + - Added support for YEAR type (533556) + + - ResultSet.insertRow() should now detect auto_increment fields + in most cases and use that value in the new row. This detection + will not work in multi-valued keys, however, due to the fact that + the MySQL protocol does not return this information. + + - ResultSet.refreshRow() implemented. + + - Fixed testsuite.Traversal afterLast() bug, thanks to Igor Lastric. + +01-27-02 - Version 2.0.11 + + - Fixed missing DELETE_RULE value in + DBMD.getImported/ExportedKeys() and getCrossReference(). + + - Full synchronization of Statement.java. + + - More changes to fix "Unexpected end of input stream" + errors when reading BLOBs. This should be the last fix. + +01-24-02 - Version 2.0.10 + + - Fixed spurious "Unexpected end of input stream" errors in + MysqlIO (bug 507456). + + - Fixed null-pointer-exceptions when using + MysqlConnectionPoolDataSource with Websphere 4 (bug 505839). + +01-13-02 - Version 2.0.9 + + - Ant build was corrupting included jar files, fixed + (bug 487669). + + - Fixed extra memory allocation in MysqlIO.readPacket() + (bug 488663). + + - Implementation of DatabaseMetaData.getExported/ImportedKeys() and + getCrossReference(). + + - Full synchronization on methods modifying instance and class-shared + references, driver should be entirely thread-safe now (please + let me know if you have problems) + + - DataSource implementations moved to org.gjt.mm.mysql.jdbc2.optional + package, and (initial) implementations of PooledConnectionDataSource + and XADataSource are in place (thanks to Todd Wolff for the + implementation and testing of PooledConnectionDataSource with + IBM WebSphere 4). + + - Added detection of network connection being closed when reading packets + (thanks to Todd Lizambri). + + - Fixed quoting error with escape processor (bug 486265). + + - Report batch update support through DatabaseMetaData (bug 495101). + + - Fixed off-by-one-hour error in PreparedStatement.setTimestamp() + (bug 491577). + + - Removed concatenation support from driver (the '||' operator), + as older versions of VisualAge seem to be the only thing that + use it, and it conflicts with the logical '||' operator. You will + need to start mysqld with the "--ansi" flag to use the '||' + operator as concatenation (bug 491680) + + - Fixed casting bug in PreparedStatement (bug 488663). + +11-25-01 - Version 2.0.8 + + - Batch updates now supported (thanks to some inspiration + from Daniel Rall). + + - XADataSource/ConnectionPoolDataSource code (experimental) + + - PreparedStatement.setAnyNumericType() now handles positive + exponents correctly (adds "+" so MySQL can understand it). + + - DatabaseMetaData.getPrimaryKeys() and getBestRowIdentifier() + are now more robust in identifying primary keys (matches + regardless of case or abbreviation/full spelling of Primary Key + in Key_type column). + +10-24-01 - Version 2.0.7 + + - PreparedStatement.setCharacterStream() now implemented + + - Fixed dangling socket problem when in high availability + (autoReconnect=true) mode, and finalizer for Connection will + close any dangling sockets on GC. + + - Fixed ResultSetMetaData.getPrecision() returning one + less than actual on newer versions of MySQL. + + - ResultSet.getBlob() now returns null if column value + was null. + + - Character sets read from database if useUnicode=true + and characterEncoding is not set. (thanks to + Dmitry Vereshchagin) + + - Initial transaction isolation level read from + database (if avaialable) (thanks to Dmitry Vereshchagin) + + - Fixed DatabaseMetaData.supportsTransactions(), and + supportsTransactionIsolationLevel() and getTypeInfo() + SQL_DATETIME_SUB and SQL_DATA_TYPE fields not being + readable. + + - Fixed PreparedStatement generating SQL that would end + up with syntax errors for some queries. + + - Fixed ResultSet.isAfterLast() always returning false. + + - Fixed timezone issue in PreparedStatement.setTimestamp() + (thanks to Erik Olofsson) + + - Captialize type names when "captializeTypeNames=true" + is passed in URL or properties (for WebObjects, thanks + to Anjo Krank) + + - Updatable result sets now correctly handle NULL + values in fields. + + - PreparedStatement.setDouble() now uses full-precision + doubles (reverting a fix made earlier to truncate them). + + - PreparedStatement.setBoolean() will use 1/0 for values + if your MySQL Version >= 3.21.23. + +06-16-01 - Version 2.0.6 + +Fixed PreparedStatement parameter checking + + - Fixed case-sensitive column names in ResultSet.java + +06-13-01 - Version 2.0.5 + + - Fixed ResultSet.getBlob() ArrayIndex out-of-bounds + + - Fixed ResultSetMetaData.getColumnTypeName for TEXT/BLOB + + - Fixed ArrayIndexOutOfBounds when sending large BLOB queries + (Max size packet was not being set) + + - Added ISOLATION level support to Connection.setIsolationLevel() + + - Fixed NPE on PreparedStatement.executeUpdate() when all columns + have not been set. + + - Fixed data parsing of TIMESTAMPs with 2-digit years + + - Added Byte to PreparedStatement.setObject() + + - ResultSet.getBoolean() now recognizes '-1' as 'true' + + - ResultSet has +/-Inf/inf support + + - ResultSet.insertRow() works now, even if not all columns are + set (they will be set to "NULL") + + - DataBaseMetaData.getCrossReference() no longer ArrayIndexOOB + + - getObject() on ResultSet correctly does TINYINT->Byte and + SMALLINT->Short + +12-03-00 - Version 2.0.3 + + - Implemented getBigDecimal() without scale component + for JDBC2. + + - Fixed composite key problem with updateable result sets. + + - Added detection of -/+INF for doubles. + + - Faster ASCII string operations. + + - Fixed incorrect detection of MAX_ALLOWED_PACKET, so sending + large blobs should work now. + + - Fixed off-by-one error in java.sql.Blob implementation code. + + - Added "ultraDevHack" URL parameter, set to "true" to allow + (broken) Macromedia UltraDev to use the driver. + +04-06-00 - Version 2.0.1 + + - Fixed RSMD.isWritable() returning wrong value. + Thanks to Moritz Maass. + + - Cleaned up exception handling when driver connects + + - Columns that are of type TEXT now return as Strings + when you use getObject() + + - DatabaseMetaData.getPrimaryKeys() now works correctly wrt + to key_seq. Thanks to Brian Slesinsky. + + - No escape processing is done on PreparedStatements anymore + per JDBC spec. + + - Fixed many JDBC-2.0 traversal, positioning bugs, especially + wrt to empty result sets. Thanks to Ron Smits, Nick Brook, + Cessar Garcia and Carlos Martinez. + + - Fixed some issues with updatability support in ResultSet when + using multiple primary keys. + +02-21-00 - Version 2.0pre5 + + - Fixed Bad Handshake problem. + +01-10-00 - Version 2.0pre4 + + - Fixes to ResultSet for insertRow() - Thanks to + Cesar Garcia + + - Fix to Driver to recognize JDBC-2.0 by loading a JDBC-2.0 + class, instead of relying on JDK version numbers. Thanks + to John Baker. + + - Fixed ResultSet to return correct row numbers + + - Statement.getUpdateCount() now returns rows matched, + instead of rows actually updated, which is more SQL-92 + like. + +10-29-99 + + - Statement/PreparedStatement.getMoreResults() bug fixed. + Thanks to Noel J. Bergman. + + - Added Short as a type to PreparedStatement.setObject(). + Thanks to Jeff Crowder + + - Driver now automagically configures maximum/preferred packet + sizes by querying server. + + - Autoreconnect code uses fast ping command if server supports + it. + + - Fixed various bugs wrt. to packet sizing when reading from + the server and when alloc'ing to write to the server. + +08-17-99 - Version 2.0pre + + - Now compiles under JDK-1.2. The driver supports both JDK-1.1 + and JDK-1.2 at the same time through a core set of classes. + The driver will load the appropriate interface classes at + runtime by figuring out which JVM version you are using. + + - Fixes for result sets with all nulls in the first row. + (Pointed out by Tim Endres) + + - Fixes to column numbers in SQLExceptions in ResultSet + (Thanks to Blas Rodriguez Somoza) + + - The database no longer needs to specified to connect. + (Thanks to Christian Motschke) + +07-04-99 - Version 1.2b + + - Better Documentation (in progress), in doc/mm.doc/book1.html + + - DBMD now allows null for a column name pattern (not in + spec), which it changes to '%'. + + - DBMD now has correct types/lengths for getXXX(). + + - ResultSet.getDate(), getTime(), and getTimestamp() fixes. + (contributed by Alan Wilken) + + - EscapeProcessor now handles \{ \} and { or } inside quotes + correctly. (thanks to Alik for some ideas on how to fix it) + + - Fixes to properties handling in Connection. + (contributed by Juho Tikkala) + + - ResultSet.getObject() now returns null for NULL columns + in the table, rather than bombing out. + (thanks to Ben Grosman) + + - ResultSet.getObject() now returns Strings for types + from MySQL that it doesn't know about. (Suggested by + Chris Perdue) + + - Removed DataInput/Output streams, not needed, 1/2 number + of method calls per IO operation. + + - Use default character encoding if one is not specified. This + is a work-around for broken JVMs, because according to spec, + EVERY JVM must support "ISO8859_1", but they don't. + + - Fixed Connection to use the platform character encoding + instead of "ISO8859_1" if one isn't explicitly set. This + fixes problems people were having loading the character- + converter classes that didn't always exist (JVM bug). + (thanks to Fritz Elfert for pointing out this problem) + + - Changed MysqlIO to re-use packets where possible to reduce + memory usage. + + - Fixed escape-processor bugs pertaining to {} inside + quotes. + +04-14-99 - Version 1.2a + + - Fixed character-set support for non-Javasoft JVMs + (thanks to many people for pointing it out) + + - Fixed ResultSet.getBoolean() to recognize 'y' & 'n' + as well as '1' & '0' as boolean flags. + (thanks to Tim Pizey) + + - Fixed ResultSet.getTimestamp() to give better performance. + (thanks to Richard Swift) + + - Fixed getByte() for numeric types. + (thanks to Ray Bellis) + + - Fixed DatabaseMetaData.getTypeInfo() for DATE type. + (thanks to Paul Johnston) + + - Fixed EscapeProcessor for "fn" calls. + (thanks to Piyush Shah at locomotive.org) + + - Fixed EscapeProcessor to not do extraneous work if there + are no escape codes. + (thanks to Ryan Gustafson) + + - Fixed Driver to parse URLs of the form "jdbc:mysql://host:port" + (thanks to Richard Lobb) + +03-24-99 - Version 1.1i + + - Fixed Timestamps for PreparedStatements + + - Fixed null pointer exceptions in RSMD and RS + + - Re-compiled with jikes for valid class files (thanks ms!) + +03-08-99 - Version 1.1h + + - Fixed escape processor to deal with un-matched { and } + (thanks to Craig Coles) + + - Fixed escape processor to create more portable (between + DATETIME and TIMESTAMP types) representations so that + it will work with BETWEEN clauses. + (thanks to Craig Longman) + + - MysqlIO.quit() now closes the socket connection. Before, + after many failed connections some OS's would run out + of file descriptors. (thanks to Michael Brinkman) + + - Fixed NullPointerException in Driver.getPropertyInfo. + (thanks to Dave Potts) + + - Fixes to MysqlDefs to allow all *text fields to be + retrieved as Strings. + (thanks to Chris at Leverage) + + - Fixed setDouble in PreparedStatement for large numbers + to avoid sending scientific notation to the database. + (thanks to J.S. Ferguson) + + - Fixed getScale() and getPrecision() in RSMD. + (contrib'd by James Klicman) + + - Fixed getObject() when field was DECIMAL or NUMERIC + (thanks to Bert Hobbs) + + - DBMD.getTables() bombed when passed a null table-name + pattern. Fixed. (thanks to Richard Lobb) + + - Added check for "client not authorized" errors during + connect. (thanks to Hannes Wallnoefer) + +02-19-99 - Version 1.1g + + - Result set rows are now byte arrays. Blobs and Unicode + work bidriectonally now. The useUnicode and encoding + options are implemented now. + + - Fixes to PreparedStatement to send binary set by + setXXXStream to be sent un-touched to the MySQL server. + + - Fixes to getDriverPropertyInfo(). + +12-31-98 - Version 1.1f + + - Changed all ResultSet fields to Strings, this should allow + Unicode to work, but your JVM must be able to convert + between the character sets. This should also make reading + data from the server be a bit quicker, because there is now + no conversion from StringBuffer to String. + + - Changed PreparedStatement.streamToString() to be more + efficient (code from Uwe Schaefer). + + - URL parsing is more robust (throws SQL exceptions on errors + rather than NullPointerExceptions) + + - PreparedStatement now can convert Strings to Time/Date values + via setObject() (code from Robert Currey). + + - IO no longer hangs in Buffer.readInt(), that bug was + introduced in 1.1d when changing to all byte-arrays for + result sets. (Pointed out by Samo Login) + +11-03-98 - Version 1.1b + + - Fixes to DatabaseMetaData to allow both IBM VA and J-Builder + to work. Let me know how it goes. (thanks to Jac Kersing) + + - Fix to ResultSet.getBoolean() for NULL strings + (thanks to Barry Lagerweij) + + - Beginning of code cleanup, and formatting. Getting ready + to branch this off to a parallel JDBC-2.0 source tree. + + - Added "final" modifier to critical sections in MysqlIO and + Buffer to allow compiler to inline methods for speed. + +9-29-98 + + - If object references passed to setXXX() in PreparedStatement are + null, setNull() is automatically called for you. (Thanks for the + suggestion goes to Erik Ostrom) + + - setObject() in PreparedStatement will now attempt to write a + serialized representation of the object to the database for + objects of Types.OTHER and objects of unknown type. + + - Util now has a static method readObject() which given a ResultSet + and a column index will re-instantiate an object serialized in + the above manner. + +9-02-98 - Vesion 1.1 + + - Got rid of "ugly hack" in MysqlIO.nextRow(). Rather than + catch an exception, Buffer.isLastDataPacket() was fixed. + + - Connection.getCatalog() and Connection.setCatalog() + should work now. + + - Statement.setMaxRows() works, as well as setting + by property maxRows. Statement.setMaxRows() overrides + maxRows set via properties or url parameters. + + - Automatic re-connection is available. Because it has + to "ping" the database before each query, it is + turned off by default. To use it, pass in "autoReconnect=true" + in the connection URL. You may also change the number of + reconnect tries, and the initial timeout value via + "maxReconnects=n" (default 3) and "initialTimeout=n" + (seconds, default 2) parameters. The timeout is an + exponential backoff type of timeout, e.g. if you have initial + timeout of 2 seconds, and maxReconnects of 3, then the driver + will timeout 2 seconds, 4 seconds, then 16 seconds between each + re-connection attempt. + +8-24-98 - Version 1.0 + + - Fixed handling of blob data in Buffer.java + + - Fixed bug with authentication packet being + sized too small. + + - The JDBC Driver is now under the LPGL + +8-14-98 - + + - Fixed Buffer.readLenString() to correctly + read data for BLOBS. + + - Fixed PreparedStatement.stringToStream to + correctly read data for BLOBS. + + - Fixed PreparedStatement.setDate() to not + add a day. + (above fixes thanks to Vincent Partington) + + - Added URL parameter parsing (?user=... etc). + + +8-04-98 - Version 0.9d + + - Big news! New package name. Tim Endres from ICE + Engineering is starting a new source tree for + GNU GPL'd Java software. He's graciously given + me the org.gjt.mm package directory to use, so now + the driver is in the org.gjt.mm.mysql package scheme. + I'm "legal" now. Look for more information on Tim's + project soon. + + - Now using dynamically sized packets to reduce + memory usage when sending commands to the DB. + + - Small fixes to getTypeInfo() for parameters, etc. + + - DatabaseMetaData is now fully implemented. Let me + know if these drivers work with the various IDEs + out there. I've heard that they're working with + JBuilder right now. + + - Added JavaDoc documentation to the package. + + - Package now available in .zip or .tar.gz. + +7-28-98 - Version 0.9 + + - Implemented getTypeInfo(). + Connection.rollback() now throws an SQLException + per the JDBC spec. + + - Added PreparedStatement that supports all JDBC API + methods for PreparedStatement including InputStreams. + Please check this out and let me know if anything is + broken. + + - Fixed a bug in ResultSet that would break some + queries that only returned 1 row. + + - Fixed bugs in DatabaseMetaData.getTables(), + DatabaseMetaData.getColumns() and + DatabaseMetaData.getCatalogs(). + + - Added functionality to Statement that allows + executeUpdate() to store values for IDs that are + automatically generated for AUTO_INCREMENT fields. + Basically, after an executeUpdate(), look at the + SQLWarnings for warnings like "LAST_INSERTED_ID = + 'some number', COMMAND = 'your SQL query'". + + If you are using AUTO_INCREMENT fields in your + tables and are executing a lot of executeUpdate()s + on one Statement, be sure to clearWarnings() every + so often to save memory. + +7-06-98 - Version 0.8 + + - Split MysqlIO and Buffer to separate classes. Some + ClassLoaders gave an IllegalAccess error for some + fields in those two classes. Now mm.mysql works in + applets and all classloaders. + + Thanks to Joe Ennis for pointing + out the problem and working on a fix with me. + +7-01-98 - Version 0.7 + + - Fixed DatabaseMetadata problems in getColumns() and + bug in switch statement in the Field constructor. + + Thanks to Costin Manolache for + pointing these out. + +5-21-98 - Version 0.6 + + - Incorporated efficiency changes from + Richard Swift in + MysqlIO.java and ResultSet.java + + - We're now 15% faster than gwe's driver. + + - Started working on DatabaseMetaData. + + The following methods are implemented: + * getTables() + * getTableTypes() + * getColumns + * getCatalogs() diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/INFO_BIN b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/INFO_BIN new file mode 100644 index 0000000..a7b74e4 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/INFO_BIN @@ -0,0 +1,4 @@ +build-date: 2021-06-08 16:39:29 +0000 +os-info: Linux i386 4.1.12-124.48.6.el6uek.x86_64 +compiler: javac 1.8.0_241 +build-tool: Apache Ant(TM) version 1.10.7 compiled on September 1 2019 diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/INFO_SRC b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/INFO_SRC new file mode 100644 index 0000000..daf42e8 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/INFO_SRC @@ -0,0 +1,5 @@ +version: 8.0.26 +branch: release/8.0.26 +date: 2021-06-08 14:49:03 +0100 +commit: 9aae1e450989d62c06616c1dcda3e404ef84df70 +short: 9aae1e45 diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/LICENSE b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/LICENSE new file mode 100644 index 0000000..e66b83f --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/LICENSE @@ -0,0 +1,1976 @@ +Licensing Information User Manual + +MySQL Connector/J 8.0 + __________________________________________________________________ + +Introduction + + This License Information User Manual contains Oracle's product license + and other licensing information, including licensing information for + third-party software which may be included in this distribution of + MySQL Connector/J 8.0. + + Last updated: April 2021 + +Licensing Information + + This is a release of MySQL Connector/J 8.0, brought to you by the MySQL + team at Oracle. This software is released under version 2 of the GNU + General Public License (GPLv2), as set forth below, with the following + additional permissions: + + This distribution of MySQL Connector/J 8.0 is distributed with certain + software that is licensed under separate terms, as designated in a + particular file or component or in the license documentation. Without + limiting your rights under the GPLv2, the authors of MySQL hereby grant + you an additional permission to link the program and your derivative + works with the separately licensed software that they have included + with the program. + + Without limiting the foregoing grant of rights under the GPLv2 and + additional permission as to separately licensed software, this + Connector is also subject to the Universal FOSS Exception, version 1.0, + a copy of which is reproduced below and can also be found along with + its FAQ at http://oss.oracle.com/licenses/universal-foss-exception. + + Copyright (c) 2017, 2021, Oracle and/or its affiliates. + +Election of GPLv2 + + For the avoidance of doubt, except that if any license choice other + than GPL or LGPL is available it will apply instead, Oracle elects to + use only the General Public License version 2 (GPLv2) at this time for + any software where a choice of GPL license versions is made available + with the language indicating that GPLv2 or any later version may be + used, or where a choice of which version of the GPL is applied is + otherwise unspecified. + +GNU General Public License Version 2.0, June 1991 + +The following applies to all products licensed under the GNU General +Public License, Version 2.0: You may not use the identified files +except in compliance with the GNU General Public License, Version +2.0 (the "License.") You may obtain a copy of the License at +http://www.gnu.org/licenses/gpl-2.0.txt. A copy of the license is +also reproduced below. Unless required by applicable law or agreed +to in writing, software distributed under the License is distributed +on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, +either express or implied. See the License for the specific language +governing permissions and limitations under the License. + + + ====================================================================== + ====================================================================== + + +GNU GENERAL PUBLIC LICENSE +Version 2, June 1991 + +Copyright (C) 1989, 1991 Free Software Foundation, Inc., +51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA +Everyone is permitted to copy and distribute verbatim +copies of this license document, but changing it is not +allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, +and (2) offer you this license which gives you legal permission to +copy, distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, +we want its recipients to know that what they have is not the original, +so that any problems introduced by others will not reflect on the +original authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software + interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as +a special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new +versions of the General Public License from time to time. Such new +versions will be similar in spirit to the present version, but may +differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Program does not specify a +version number of this License, you may choose any version ever +published by the Free Software Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the +author to ask for permission. For software which is copyrighted by the +Free Software Foundation, write to the Free Software Foundation; we +sometimes make exceptions for this. Our decision will be guided by the +two goals of preserving the free status of all derivatives of our free +software and of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, +EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. +THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS +WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of + + the License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301 USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details + type 'show w'. This is free software, and you are welcome + to redistribute it under certain conditions; type 'show c' + for details. + +The hypothetical commands 'show w' and 'show c' should show the +appropriate parts of the General Public License. Of course, the +commands you use may be called something other than 'show w' and +'show c'; they could even be mouse-clicks or menu items--whatever +suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + program 'Gnomovision' (which makes passes at compilers) written + by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, +you may consider it more useful to permit linking proprietary +applications with the library. If this is what you want to do, use +the GNU Lesser General Public License instead of this License. + + ====================================================================== + ====================================================================== + +The Universal FOSS Exception, Version 1.0 + + In addition to the rights set forth in the other license(s) included in + the distribution for this software, data, and/or documentation + (collectively the "Software", and such licenses collectively with this + additional permission the "Software License"), the copyright holders + wish to facilitate interoperability with other software, data, and/or + documentation distributed with complete corresponding source under a + license that is OSI-approved and/or categorized by the FSF as free + (collectively "Other FOSS"). We therefore hereby grant the following + additional permission with respect to the use and distribution of the + Software with Other FOSS, and the constants, function signatures, data + structures and other invocation methods used to run or interact with + each of them (as to each, such software's "Interfaces"): + i. The Software's Interfaces may, to the extent permitted by the + license of the Other FOSS, be copied into, used and distributed in + the Other FOSS in order to enable interoperability, without + requiring a change to the license of the Other FOSS other than as + to any Interfaces of the Software embedded therein. The Software's + Interfaces remain at all times under the Software License, + including without limitation as used in the Other FOSS (which upon + any such use also then contains a portion of the Software under the + Software License). + ii. The Other FOSS's Interfaces may, to the extent permitted by the + license of the Other FOSS, be copied into, used and distributed in + the Software in order to enable interoperability, without requiring + that such Interfaces be licensed under the terms of the Software + License or otherwise altering their original terms, if this does + not require any portion of the Software other than such Interfaces + to be licensed under the terms other than the Software License. + iii. If only Interfaces and no other code is copied between the + Software and the Other FOSS in either direction, the use and/or + distribution of the Software with the Other FOSS shall not be + deemed to require that the Other FOSS be licensed under the license + of the Software, other than as to any Interfaces of the Software + copied into the Other FOSS. This includes, by way of example and + without limitation, statically or dynamically linking the Software + together with Other FOSS after enabling interoperability using the + Interfaces of one or both, and distributing the resulting + combination under different licenses for the respective portions + thereof. For avoidance of doubt, a license which is OSI-approved or + categorized by the FSF as free, includes, for the purpose of this + permission, such licenses with additional permissions, and any + license that has previously been so approved or categorized as + free, even if now deprecated or otherwise no longer recognized as + approved or free. Nothing in this additional permission grants any + right to distribute any portion of the Software on terms other than + those of the Software License or grants any additional permission + of any kind for use or distribution of the Software in conjunction + with software other than Other FOSS. + + ====================================================================== + ====================================================================== + +Licenses for Third-Party Components + + The following sections contain licensing information for libraries that + may be included with this product. We are thankful to all individuals + that have created these. Standard licenses referenced herein are + detailed in the Standard Licenses section. + +c3p0 JDBC Library + + The MySQL Connector/J implements interfaces that are included in c3p0, + although no part of c3p0 is included or distributed with MySQL. +Copyright (C) 2019 Machinery For Change, Inc. + + * This library is free software; you can redistribute it and/or modify + * it under the terms of EITHER: + * + * 1) The GNU Lesser General Public License (LGPL), version 2.1, as + * published by the Free Software Foundation + * + * OR + * + * 2) The Eclipse Public License (EPL), version 1.0 + * You may choose which license to accept if you wish to redistribute + * or modify this work. You may offer derivatives of this work + * under the license you have chosen, or you may provide the same + * choice of license which you have been offered here. + * + * This software is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. + * + * You should have received copies of both LGPL v2.1 and EPL v1.0 + * along with this software; see the files LICENSE-EPL and LICENSE-LGPL. + * If not, the text of these licenses are currently available at + * + * LGPL v2.1: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html + * EPL v1.0: http://www.eclipse.org/org/documents/epl-v10.php + +Eclipse Public License - v 1.0 + +THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC +LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM +CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. + +1. DEFINITIONS + +"Contribution" means: + +a) in the case of the initial Contributor, the initial code and documentation + + distributed under this Agreement, and + +b) in the case of each subsequent Contributor: + + i) changes to the Program, and + + ii) additions to the Program; + +where such changes and/or additions to the Program originate from and are +distributed by that particular Contributor. A Contribution 'originates' from a +Contributor if it was added to the Program by such Contributor itself or anyone +acting on such Contributor's behalf. Contributions do not include additionsto +the Program which: (i) are separate modules of software distributed in +conjunction with the Program under their own license agreement, and (ii) are not +derivative works of the Program. + +"Contributor" means any person or entity that distributes the Program. + +"Licensed Patents " mean patent claims licensable by a Contributor which are +necessarily infringed by the use or sale of its Contribution alone or when +combined with the Program. + +"Program" means the Contributions distributed in accordance with this +Agreement. + +"Recipient" means anyone who receives the Program under this Agreement, +including all Contributors. + +2. GRANT OF RIGHTS + +a) Subject to the terms of this Agreement, each Contributor hereby grants +Recipient a non-exclusive, worldwide, royalty-free copyright license to +reproduce, prepare derivative works of, publicly display, publicly perform, +distribute and sublicense the Contribution of such Contributor, if any, and such +derivative works, in source code and object code form. + +b) Subject to the terms of this Agreement, each Contributor hereby grants +Recipient a non-exclusive, worldwide, royalty-free patent license under Licensed +Patents to make, use, sell, offer to sell, import and otherwise transfer the +Contribution of such Contributor, if any, in source code and object code form. +This patent license shall apply to the combination of the Contribution and the +Program if, at the time the Contribution is added by the Contributor, such +addition of the Contribution causes such combination to be covered by the +Licensed Patents. The patent license shall not apply to any other combinations +which include the Contribution. No hardware per se is licensed hereunder. + +c) Recipient understands that although each Contributor grants the licenses to +its Contributions set forth herein, no assurances are provided by any +Contributor that the Program does not infringe the patent or other intellectual +property rights of any other entity. Each Contributor disclaims any liability to +Recipient for claims brought by any other entity based on infringement of +intellectual property rights or otherwise. As a condition to exercising the +rights and licenses granted hereunder, each Recipient hereby assumes sole +responsibility to secure any other intellectual property rights needed, if any. +For example, if a third party patent license is required to allow Recipient to +distribute the Program, it is Recipient's responsibility to acquire that license +before distributing the Program. + +d) Each Contributor represents that to its knowledge it has sufficient +copyright rights in its Contribution, if any, to grant the copyright license +set forth in this Agreement. + +3. REQUIREMENTS + +A Contributor may choose to distribute the Program in object code form under +its own license agreement, provided that: + +a) it complies with the terms and conditions of this Agreement; and + +b) its license agreement: + + i) effectively disclaims on behalf of all Contributors all warranties + and conditions, express and implied, including warranties or conditions + of title and non-infringement, and implied warranties or conditions of + merchantability and fitness for a particular purpose; + + ii) effectively excludes on behalf of all Contributors all liability for + damages, including direct, indirect, special, incidental and + consequential damages, such as lost profits; + + iii) states that any provisions which differ from this Agreement are + offered by that Contributor alone and not by any other party; and + + iv) states that source code for the Program is available from such + Contributor, and informs licensees how to obtain it in a reasonable + manner on or through a medium customarily used for software exchange. + +When the Program is made available in source code form: + +a) it must be made available under this Agreement; and + +b) a copy of this Agreement must be included with each copy of the Program. + +Contributors may not remove or alter any copyright notices contained within +the Program. + +Each Contributor must identify itself as the originator of its Contribution, +if any, in a manner that reasonably allows subsequent Recipients to identify +the originator of the Contribution. + +4. COMMERCIAL DISTRIBUTION + +Commercial distributors of software may accept certain responsibilities with +respect to end users, business partners and the like. While this license is +intended to facilitate the commercial use of the Program, the Contributor who +includes the Program in a commercial product offering should do so in a manner +which does not create potential liability for other Contributors. Therefore, if +a Contributor includes the Program in a commercial product offering, such +Contributor ("Commercial Contributor") hereby agrees to defend and indemnify +every other Contributor ("Indemnified Contributor") against any losses, damages +and costs (collectively "Losses") arising from claims, lawsuits and other legal +actions brought by a third party against the Indemnified Contributor to the +extent caused by the acts or omissions of such Commercial Contributor in +connection with its distribution of the Program in a commercial product +offering. The obligations in this section do not apply to any claims or Losses +relating to any actual or alleged intellectual property infringement. In order +to qualify, an Indemnified Contributor must: a) promptly notify the Commercial +Contributor in writing of such claim, and b) allow the Commercial Contributor to +control, and cooperate with the Commercial Contributor in, the defense and any +related settlement negotiations. The Indemnified Contributor may participate in +any such claim at its own expense. + +For example, a Contributor might include the Program in a commercial product +offering, Product X. That Contributor is then a Commercial Contributor. If that +Commercial Contributor then makes performance claims, or offers warranties +related to Product X, those performance claims and warranties are such +Commercial Contributor's responsibility alone. Under this section, the +Commercial Contributor would have to defend claims against the other +Contributors related to those performance claims and warranties, and if a court +requires any other Contributor to pay any damages as a result, the Commercial +Contributor must pay those damages. + +5. NO WARRANTY + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN +"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR +IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, +NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each +Recipient is solely responsible for determining the appropriateness of using and +distributing the Program and assumes all risks associated with its exercise of +rights under this Agreement , including but not limited to the risks and costs +of program errors, compliance with applicable laws, damage to or loss of data, +programs or equipment, and unavailability or interruption of operations. + +6. DISCLAIMER OF LIABILITY + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY +CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST +PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, +STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY +OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS +GRANTED HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + +7. GENERAL + +If any provision of this Agreement is invalid or unenforceable under applicable +law, it shall not affect the validity or enforceability of the remainder of the +terms of this Agreement, and without further action by the parties hereto, such +provision shall be reformed to the minimum extent necessary to make such +provision valid and enforceable. + +If Recipient institutes patent litigation against any entity (including a +cross-claim or counterclaim in a lawsuit) alleging that the Program itself +(excluding combinations of the Program with other software or hardware) +infringes such Recipient's patent(s), then such Recipient's rights granted under +Section 2(b) shall terminate as of the date such litigation is filed. + +All Recipient's rights under this Agreement shall terminate if it fails to +comply with any of the material terms or conditions of this Agreement and does +not cure such failure in a reasonable period of time after becoming aware of +such noncompliance. If all Recipient's rights under this Agreement terminate, +Recipient agrees to cease use and distribution of the Program as soon as +reasonably practicable. However, Recipient's obligations under this Agreement +and any licenses granted by Recipient relating to the Program shall continue and +survive. + +Everyone is permitted to copy and distribute copies of this Agreement, but in +order to avoid inconsistency the Agreement is copyrighted and may only be +modified in the following manner. The Agreement Steward reserves the right to +publish new versions (including revisions) of this Agreement from time to time. +No one other than the Agreement Steward has the right to modify this Agreement. +The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation +may assign the responsibility to serve as the Agreement Steward to a suitable +separate entity. Each new version of the Agreement will be given a +distinguishing version number. The Program (including Contributions) may always +be distributed subject to the version of the Agreement under which it was +received. In addition, after a new version of the Agreement is published, +Contributor may elect to distribute the Program (including its Contributions) +under the new version. Except as expressly stated in Sections 2(a) and 2(b) +above, Recipient receives no rights or licenses to the intellectual property of +any Contributor under this Agreement, whether expressly, by implication, +estoppel or otherwise. All rights in the Program not expressly granted under +this Agreement are reserved. + +This Agreement is governed by the laws of the State of New York and the +intellectual property laws of the United States of America. No party to this +Agreement will bring a legal action under this Agreement more than one year +after the cause of action arose. Each party waives its rights to a jury trial in +any resulting litigation. + + The LGPL v2.1 can be found in GNU Lesser General Public License Version + 2.1, February 1999. + + ====================================================================== + ====================================================================== + +Google Protocol Buffers + +Copyright 2008 Google Inc. All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are +met: + + * Redistributions of source code must retain the above copyright +notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above +copyright notice, this list of conditions and the following disclaimer +in the documentation and/or other materials provided with the +distribution. + * Neither the name of Google Inc. nor the names of its +contributors may be used to endorse or promote products derived from +this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +Code generated by the Protocol Buffer compiler is owned by the owner +of the input file used when generating it. This code is not +standalone and requires a support library to be linked with it. This +support library is itself covered by the above license. + + ====================================================================== + ====================================================================== + +Java Hamcrest + +Copyright (c) 2000-2015 www.hamcrest.org +All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + +Redistributions of source code must retain the above copyright notice, this list +of conditions and the following disclaimer. Redistributions in binary form must +reproduce the above copyright notice, this list of conditions and the following +disclaimer in the documentation and/or other materials provided with the +distribution. + +Neither the name of Hamcrest nor the names of its contributors may be used to +endorse or promote products derived from this software without specific prior +written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + + ====================================================================== + ====================================================================== + +JUnit 5 + +COPYRIGHT: Copyright 2015-2020 the original author or authors. + +Eclipse Public License - v 2.0 + + THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE + PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION + OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT. + +1. DEFINITIONS + +"Contribution" means: + + a) in the case of the initial Contributor, the initial content + Distributed under this Agreement, and + + b) in the case of each subsequent Contributor: + i) changes to the Program, and + ii) additions to the Program; + where such changes and/or additions to the Program originate from + and are Distributed by that particular Contributor. A Contribution + "originates" from a Contributor if it was added to the Program by + such Contributor itself or anyone acting on such Contributor's behalf. + Contributions do not include changes or additions to the Program that + are not Modified Works. + +"Contributor" means any person or entity that Distributes the Program. + +"Licensed Patents" mean patent claims licensable by a Contributor which +are necessarily infringed by the use or sale of its Contribution alone +or when combined with the Program. + +"Program" means the Contributions Distributed in accordance with this +Agreement. + +"Recipient" means anyone who receives the Program under this Agreement +or any Secondary License (as applicable), including Contributors. + +"Derivative Works" shall mean any work, whether in Source Code or other +form, that is based on (or derived from) the Program and for which the +editorial revisions, annotations, elaborations, or other modifications +represent, as a whole, an original work of authorship. + +"Modified Works" shall mean any work in Source Code or other form that +results from an addition to, deletion from, or modification of the +contents of the Program, including, for purposes of clarity any new file +in Source Code form that contains any contents of the Program. Modified +Works shall not include works that contain only declarations, +interfaces, types, classes, structures, or files of the Program solely +in each case in order to link to, bind by name, or subclass the Program +or Modified Works thereof. + +"Distribute" means the acts of a) distributing or b) making available +in any manner that enables the transfer of a copy. + +"Source Code" means the form of a Program preferred for making +modifications, including but not limited to software source code, +documentation source, and configuration files. + +"Secondary License" means either the GNU General Public License, +Version 2.0, or any later versions of that license, including any +exceptions or additional permissions as identified by the initial +Contributor. + +2. GRANT OF RIGHTS + + a) Subject to the terms of this Agreement, each Contributor hereby + grants Recipient a non-exclusive, worldwide, royalty-free copyright + license to reproduce, prepare Derivative Works of, publicly display, + publicly perform, Distribute and sublicense the Contribution of such + Contributor, if any, and such Derivative Works. + + b) Subject to the terms of this Agreement, each Contributor hereby + grants Recipient a non-exclusive, worldwide, royalty-free patent + license under Licensed Patents to make, use, sell, offer to sell, + import and otherwise transfer the Contribution of such Contributor, + if any, in Source Code or other form. This patent license shall + apply to the combination of the Contribution and the Program if, at + the time the Contribution is added by the Contributor, such addition + of the Contribution causes such combination to be covered by the + Licensed Patents. The patent license shall not apply to any other + combinations which include the Contribution. No hardware per se is + licensed hereunder. + + c) Recipient understands that although each Contributor grants the + licenses to its Contributions set forth herein, no assurances are + provided by any Contributor that the Program does not infringe the + patent or other intellectual property rights of any other entity. + Each Contributor disclaims any liability to Recipient for claims + brought by any other entity based on infringement of intellectual + property rights or otherwise. As a condition to exercising the + rights and licenses granted hereunder, each Recipient hereby + assumes sole responsibility to secure any other intellectual + property rights needed, if any. For example, if a third party + patent license is required to allow Recipient to Distribute the + Program, it is Recipient's responsibility to acquire that license + before distributing the Program. + + d) Each Contributor represents that to its knowledge it has + sufficient copyright rights in its Contribution, if any, to grant + the copyright license set forth in this Agreement. + + e) Notwithstanding the terms of any Secondary License, no + Contributor makes additional grants to any Recipient (other than + those set forth in this Agreement) as a result of such Recipient's + receipt of the Program under the terms of a Secondary License + (if permitted under the terms of Section 3). + +3. REQUIREMENTS + +3.1 If a Contributor Distributes the Program in any form, then: + + a) the Program must also be made available as Source Code, in + accordance with section 3.2, and the Contributor must accompany + the Program with a statement that the Source Code for the Program + is available under this Agreement, and informs Recipients how to + obtain it in a reasonable manner on or through a medium customarily + used for software exchange; and + + b) the Contributor may Distribute the Program under a license + different than this Agreement, provided that such license: + i) effectively disclaims on behalf of all other Contributors all + warranties and conditions, express and implied, including + warranties or conditions of title and non-infringement, and + implied warranties or conditions of merchantability and fitness + for a particular purpose; + + ii) effectively excludes on behalf of all other Contributors all + liability for damages, including direct, indirect, special, + incidental and consequential damages, such as lost profits; + + iii) does not attempt to limit or alter the recipients' rights + in the Source Code under section 3.2; and + + iv) requires any subsequent distribution of the Program by any + party to be under a license that satisfies the requirements + of this section 3. + +3.2 When the Program is Distributed as Source Code: + + a) it must be made available under this Agreement, or if the + Program (i) is combined with other material in a separate file or + files made available under a Secondary License, and (ii) the initial + Contributor attached to the Source Code the notice described in + Exhibit A of this Agreement, then the Program may be made available + under the terms of such Secondary Licenses, and + + b) a copy of this Agreement must be included with each copy of + the Program. + +3.3 Contributors may not remove or alter any copyright, patent, +trademark, attribution notices, disclaimers of warranty, or limitations +of liability ("notices") contained within the Program from any copy of +the Program which they Distribute, provided that Contributors may add +their own appropriate notices. + +4. COMMERCIAL DISTRIBUTION + +Commercial distributors of software may accept certain responsibilities +with respect to end users, business partners and the like. While this +license is intended to facilitate the commercial use of the Program, +the Contributor who includes the Program in a commercial product +offering should do so in a manner which does not create potential +liability for other Contributors. Therefore, if a Contributor includes +the Program in a commercial product offering, such Contributor +("Commercial Contributor") hereby agrees to defend and indemnify every +other Contributor ("Indemnified Contributor") against any losses, +damages and costs (collectively "Losses") arising from claims, lawsuits +and other legal actions brought by a third party against the Indemnified +Contributor to the extent caused by the acts or omissions of such +Commercial Contributor in connection with its distribution of the Program +in a commercial product offering. The obligations in this section do not +apply to any claims or Losses relating to any actual or alleged +intellectual property infringement. In order to qualify, an Indemnified +Contributor must: a) promptly notify the Commercial Contributor in +writing of such claim, and b) allow the Commercial Contributor to control, +and cooperate with the Commercial Contributor in, the defense and any +related settlement negotiations. The Indemnified Contributor may +participate in any such claim at its own expense. + +For example, a Contributor might include the Program in a commercial +product offering, Product X. That Contributor is then a Commercial +Contributor. If that Commercial Contributor then makes performance +claims, or offers warranties related to Product X, those performance +claims and warranties are such Commercial Contributor's responsibility +alone. Under this section, the Commercial Contributor would have to +defend claims against the other Contributors related to those performance +claims and warranties, and if a court requires any other Contributor to +pay any damages as a result, the Commercial Contributor must pay +those damages. + +5. NO WARRANTY + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT +PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN "AS IS" +BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR +IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF +TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR +PURPOSE. Each Recipient is solely responsible for determining the +appropriateness of using and distributing the Program and assumes all +risks associated with its exercise of rights under this Agreement, +including but not limited to the risks and costs of program errors, +compliance with applicable laws, damage to or loss of data, programs +or equipment, and unavailability or interruption of operations. + +6. DISCLAIMER OF LIABILITY + +EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT +PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS +SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST +PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE +EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + +7. GENERAL + +If any provision of this Agreement is invalid or unenforceable under +applicable law, it shall not affect the validity or enforceability of +the remainder of the terms of this Agreement, and without further +action by the parties hereto, such provision shall be reformed to the +minimum extent necessary to make such provision valid and enforceable. + +If Recipient institutes patent litigation against any entity +(including a cross-claim or counterclaim in a lawsuit) alleging that the +Program itself (excluding combinations of the Program with other software +or hardware) infringes such Recipient's patent(s), then such Recipient's +rights granted under Section 2(b) shall terminate as of the date such +litigation is filed. + +All Recipient's rights under this Agreement shall terminate if it +fails to comply with any of the material terms or conditions of this +Agreement and does not cure such failure in a reasonable period of +time after becoming aware of such noncompliance. If all Recipient's +rights under this Agreement terminate, Recipient agrees to cease use +and distribution of the Program as soon as reasonably practicable. +However, Recipient's obligations under this Agreement and any licenses +granted by Recipient relating to the Program shall continue and survive. + +Everyone is permitted to copy and distribute copies of this Agreement, +but in order to avoid inconsistency the Agreement is copyrighted and +may only be modified in the following manner. The Agreement Steward +reserves the right to publish new versions (including revisions) of +this Agreement from time to time. No one other than the Agreement +Steward has the right to modify this Agreement. The Eclipse Foundation +is the initial Agreement Steward. The Eclipse Foundation may assign the +responsibility to serve as the Agreement Steward to a suitable separate +entity. Each new version of the Agreement will be given a distinguishing +version number. The Program (including Contributions) may always be +Distributed subject to the version of the Agreement under which it was +received. In addition, after a new version of the Agreement is published, +Contributor may elect to Distribute the Program (including its +Contributions) under the new version. + +Except as expressly stated in Sections 2(a) and 2(b) above, Recipient +receives no rights or licenses to the intellectual property of any +Contributor under this Agreement, whether expressly, by implication, +estoppel or otherwise. All rights in the Program not expressly granted +under this Agreement are reserved. Nothing in this Agreement is intended +to be enforceable by any entity that is not a Contributor or Recipient. +No third-party beneficiary rights are created under this Agreement. + +Exhibit A - Form of Secondary Licenses Notice + +"This Source Code may also be made available under the following +Secondary Licenses when the conditions for such availability set forth +in the Eclipse Public License, v. 2.0 are satisfied: {name license(s), +version(s), and exceptions or additional permissions here}." + + Simply including a copy of this Agreement, including this Exhibit A + is not sufficient to license the Source Code under Secondary Licenses. + + If it is not possible or desirable to put the notice in a particular + file, then You may include the notice in a location (such as a LICENSE + file in a relevant directory) where a recipient would be likely to + look for such a notice. + + You may add additional accurate notices of copyright ownership. +=============================================================================== + +This product may include a number of subcomponents with separate +copyright notices and license terms. Your use of the source code for +these subcomponents is subject to the terms and conditions of the +subcomponent's license, as noted in the LICENSE-.md +files. + +=== Copyright from source files === +/* + * Copyright 2015-2020 the original author or authors. + * + * All rights reserved. This program and the accompanying materials are + * made available under the terms of the Eclipse Public License v2.0 which + * accompanies this distribution and is available at + * + * https://www.eclipse.org/legal/epl-v20.html +*/ + +Additionall licenses +==================== + +=== junit-jupiter-params & junit-platform-console ==== +Directories include an Apache license file + +Apache License Version 2.0, January 2004 + +Additional external dependencies +================================ +https://github.com/apiguardian-team/apiguardian/archive/r1.1.0.zip +/* + * Copyright 2002-2017 the original author or authors. + * +The above component is licensed under +Apache License Version 2.0, January 2004 + +https://github.com/ota4j-team/opentest4j/archive/r1.2.0.zip +/* + * Copyright 2015-2018 the original author or authors. + * +The above component is licensed under +Apache License Version 2.0, January 2004 + + + + ====================================================================== + ====================================================================== + +Simple Logging Facade for Java (SLF4J) + +Simple Logging Facade for Java (SLF4J) + +Copyright (c) 2004-2011 QOS.ch +All rights reserved. + +Permission is hereby granted, free of charge, +to any person obtaining a copy of this software +and associated documentation files (the "Software"), +to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, +merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom +the Software is furnished to do so, subject to the +following conditions: + +The above copyright notice and this permission notice +shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY +OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT +LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS +FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO +EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE +FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN +AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE +OR OTHER DEALINGS IN THE SOFTWARE. + + ====================================================================== + ====================================================================== + +Unicode Data Files + + Unicode Data Files +COPYRIGHT AND PERMISSION NOTICE + +Copyright (c) 1991-2014 Unicode, Inc. All rights reserved. Distributed under +the Terms of Use in http://www.unicode.org/copyright.html. + +Permission is hereby granted, free of charge, to any person obtaining a copy +of the Unicode data files and any associated documentation (the "Data Files") +or Unicode software and any associated documentation (the "Software") to deal +in the Data Files or Software without restriction, including without +limitation the rights to use, copy, modify, merge, publish, distribute, +and/or sell copies of the Data Files or Software, and to permit persons to +whom the Data Files or Software are furnished to do so, provided that (a) the +above copyright notice(s) and this permission notice appear with all copies +of the Data Files or Software, (b) both the above copyright notice(s) and +this permission notice appear in associated documentation, and (c) there is +clear notice in each modified Data File or in the Software as well as in the +documentation associated with the Data File(s) or Software that the data or +software has been modified. + +THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD +PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS +NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL +DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, +WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING +OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA FILES OR +SOFTWARE. + +Except as contained in this notice, the name of a copyright holder shall not be +used in advertising or otherwise to promote the sale, use or other dealings in +these Data Files or Software without prior written authorization of the +copyright holder. + + ====================================================================== + ====================================================================== + +Standard Licenses + +GNU Lesser General Public License Version 2.1, February 1999 + +The following applies to all products licensed under the +GNU Lesser General Public License, Version 2.1: You may +not use the identified files except in compliance with +the GNU Lesser General Public License, Version 2.1 (the +"License"). You may obtain a copy of the License at +http://www.gnu.org/licenses/lgpl-2.1.html. A copy of the +license is also reproduced below. Unless required by +applicable law or agreed to in writing, software distributed +under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express +or implied. See the License for the specific language governing +permissions and limitations under the License. + + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it +becomes a de-facto standard. To achieve this, non-free programs +must be allowed to use the library. A more frequent case is that +a free library does the same job as widely used non-free libraries. +In this case, there is little to gain by limiting the free library +to free software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control +compilation and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended +to apply, and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms +of the ordinary General Public License). + + To apply these terms, attach the following notices to the library. +It is safest to attach them to the start of each source file to most +effectively convey the exclusion of warranty; and each file should +have at least the "copyright" line and a pointer to where the full +notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301 USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James + Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! + + ====================================================================== + ====================================================================== + +Apache License Version 2.0, January 2004 + +The following applies to all products licensed under the Apache 2.0 +License: You may not use the identified files except in compliance +with the Apache License, Version 2.0 (the "License.") You may obtain a +copy of the License at http://www.apache.org/licenses/LICENSE-2.0. A +copy of the license is also reproduced below. Unless required by +applicable law or agreed to in writing, software distributed under the +License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR +CONDITIONS OF ANY KIND, either express or implied. See the License for +the specific language governing permissions and limitations under the +License. + +Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + +"License" shall mean the terms and conditions for use, reproduction, +and distribution as defined by Sections 1 through 9 of this document. + +"Licensor" shall mean the copyright owner or entity authorized by the +copyright owner that is granting the License. + +"Legal Entity" shall mean the union of the acting entity and all other +entities that control, are controlled by, or are under common control +with that entity. For the purposes of this definition, "control" means +(i) the power, direct or indirect, to cause the direction or +management of such entity, whether by contract or otherwise, or (ii) +ownership of fifty percent (50%) or more of the outstanding shares, or +(iii) beneficial ownership of such entity. + +"You" (or "Your") shall mean an individual or Legal Entity exercising +permissions granted by this License. + +"Source" form shall mean the preferred form for making modifications, +including but not limited to software source code, documentation +source, and configuration files. + +"Object" form shall mean any form resulting from mechanical +transformation or translation of a Source form, including but not +limited to compiled object code, generated documentation, and +conversions to other media types. + +"Work" shall mean the work of authorship, whether in Source or Object +form, made available under the License, as indicated by a copyright +notice that is included in or attached to the work (an example is +provided in the Appendix below). + +"Derivative Works" shall mean any work, whether in Source or Object +form, that is based on (or derived from) the Work and for which the +editorial revisions, annotations, elaborations, or other modifications +represent, as a whole, an original work of authorship. For the +purposes of this License, Derivative Works shall not include works +that remain separable from, or merely link (or bind by name) to the +interfaces of, the Work and Derivative Works thereof. + +"Contribution" shall mean any work of authorship, including the +original version of the Work and any modifications or additions to +that Work or Derivative Works thereof, that is intentionally submitted +to Licensor for inclusion in the Work by the copyright owner or by an +individual or Legal Entity authorized to submit on behalf of the +copyright owner. For the purposes of this definition, "submitted" +means any form of electronic, verbal, or written communication sent to +the Licensor or its representatives, including but not limited to +communication on electronic mailing lists, source code control +systems, and issue tracking systems that are managed by, or on behalf +of, the Licensor for the purpose of discussing and improving the Work, +but excluding communication that is conspicuously marked or otherwise +designated in writing by the copyright owner as "Not a Contribution." + +"Contributor" shall mean Licensor and any individual or Legal Entity +on behalf of whom a Contribution has been received by Licensor and +subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of +this License, each Contributor hereby grants to You a perpetual, +worldwide, non-exclusive, no-charge, royalty-free, irrevocable +copyright license to reproduce, prepare Derivative Works of, publicly +display, publicly perform, sublicense, and distribute the Work and +such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of +this License, each Contributor hereby grants to You a perpetual, +worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except +as stated in this section) patent license to make, have made, use, +offer to sell, sell, import, and otherwise transfer the Work, where +such license applies only to those patent claims licensable by such +Contributor that are necessarily infringed by their Contribution(s) +alone or by combination of their Contribution(s) with the Work to +which such Contribution(s) was submitted. If You institute patent +litigation against any entity (including a cross-claim or counterclaim +in a lawsuit) alleging that the Work or a Contribution incorporated +within the Work constitutes direct or contributory patent +infringement, then any patent licenses granted to You under this +License for that Work shall terminate as of the date such litigation +is filed. + +4. Redistribution. You may reproduce and distribute copies of the Work +or Derivative Works thereof in any medium, with or without +modifications, and in Source or Object form, provided that You meet +the following conditions: + +(a) You must give any other recipients of the Work or Derivative Works +a copy of this License; and + +(b) You must cause any modified files to carry prominent notices +stating that You changed the files; and + +(c) You must retain, in the Source form of any Derivative Works that +You distribute, all copyright, patent, trademark, and attribution +notices from the Source form of the Work, excluding those notices that +do not pertain to any part of the Derivative Works; and + +(d) If the Work includes a "NOTICE" text file as part of its +distribution, then any Derivative Works that You distribute must +include a readable copy of the attribution notices contained + +within such NOTICE file, excluding those notices that do not pertain +to any part of the Derivative Works, in at least one of the following +places: within a NOTICE text file distributed as part of the +Derivative Works; within the Source form or documentation, if provided +along with the Derivative Works; or, within a display generated by the +Derivative Works, if and wherever such third-party notices normally +appear. The contents of the NOTICE file are for informational purposes +only and do not modify the License. You may add Your own attribution +notices within Derivative Works that You distribute, alongside or as +an addendum to the NOTICE text from the Work, provided that such +additional attribution notices cannot be construed as modifying the +License. + +You may add Your own copyright statement to Your modifications and may +provide additional or different license terms and conditions for use, +reproduction, or distribution of Your modifications, or for any such +Derivative Works as a whole, provided Your use, reproduction, and +distribution of the Work otherwise complies with the conditions stated +in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, +any Contribution intentionally submitted for inclusion in the Work by +You to the Licensor shall be under the terms and conditions of this +License, without any additional terms or conditions. Notwithstanding +the above, nothing herein shall supersede or modify the terms of any +separate license agreement you may have executed with Licensor +regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade +names, trademarks, service marks, or product names of the Licensor, +except as required for reasonable and customary use in describing the +origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or agreed +to in writing, Licensor provides the Work (and each Contributor +provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR +CONDITIONS OF ANY KIND, either express or implied, including, without +limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, +MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely +responsible for determining the appropriateness of using or +redistributing the Work and assume any risks associated with Your +exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, +whether in tort (including negligence), contract, or otherwise, unless +required by applicable law (such as deliberate and grossly negligent +acts) or agreed to in writing, shall any Contributor be liable to You +for damages, including any direct, indirect, special, incidental, or +consequential damages of any character arising as a result of this +License or out of the use or inability to use the Work (including but +not limited to damages for loss of goodwill, work stoppage, computer +failure or malfunction, or any and all other commercial damages or +losses), even if such Contributor has been advised of the possibility +of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing +the Work or Derivative Works thereof, You may choose to offer, and +charge a fee for, acceptance of support, warranty, indemnity, or other +liability obligations and/or rights consistent with this +License. However, in accepting such obligations, You may act only on +Your own behalf and on Your sole responsibility, not on behalf of any +other Contributor, and only if You agree to indemnify, defend, and +hold each Contributor harmless for any liability incurred by, or +claims asserted against, such Contributor by reason of your accepting +any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work + +To apply the Apache License to your work, attach the following boilerplate +notice, with the fields enclosed by brackets "[]" replaced with your own +identifying information. (Don't include the brackets!) The text should be +enclosed in the appropriate comment syntax for the file format. We also +recommend that a file or class name and description of purpose be included +on the same "printed page" as the copyright notice for easier identification +within third-party archives. + +Copyright [yyyy] [name of copyright owner] + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at +http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or +implied. See the License for the specific language governing permissions +and limitations under the License. + + ====================================================================== + ====================================================================== + +Written Offer for Source Code + + For any software that you receive from Oracle in binary form which is + licensed under an open source license that gives you the right to + receive the source code for that binary, you can obtain a copy of the + applicable source code by visiting + http://www.oracle.com/goto/opensourcecode. If the source code for the + binary was not provided to you with the binary, you can also receive a + copy of the source code on physical media by submitting a written + request to the address listed below or by sending an email to Oracle + using the following link: + http://www.oracle.com/goto/opensourcecode/request. + Oracle America, Inc. + Attn: Senior Vice President + Development and Engineering Legal + 500 Oracle Parkway, 10th Floor + Redwood Shores, CA 94065 + + Your request should include: + * The name of the binary for which you are requesting the source code + * The name and version number of the Oracle product containing the + binary + * The date you received the Oracle product + * Your name + * Your company name (if applicable) + * Your return mailing address and email, and + * A telephone number in the event we need to reach you. + + We may charge you a fee to cover the cost of physical media and + processing. + + Your request must be sent + a. within three (3) years of the date you received the Oracle product + that included the binary that is the subject of your request, or + b. in the case of code licensed under the GPL v3 for as long as Oracle + offers spare parts or customer support for that product model. diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/README b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/README new file mode 100644 index 0000000..952630f --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/README @@ -0,0 +1,28 @@ +Copyright (c) 2000, 2021, Oracle and/or its affiliates. + +This is a release of MySQL Connector/J, a JDBC Type 4 driver for MySQL that +also supports the new X DevAPI. + +License information can be found in the LICENSE file. + +This distribution may include materials developed by third parties. +For license and attribution notices for these materials, please refer to the +LICENSE file. + +For more information on MySQL Connector/J, visit + https://dev.mysql.com/doc/connector-j/8.0/en/ + +For additional downloads and the source of MySQL Connector/J, visit + https://dev.mysql.com/downloads/ + +MySQL Connector/J is brought to you by the MySQL team at Oracle. + +Notice: +- In order to use the logging capabilities provided by the default + implementation com.mysql.cj.log.Slf4JLogger, it is required to add one or + more jars for Simple Logging Facade for Java (SLF4J) to your CLASSPATH. +- To use the X DevAPI features in Connector/J, you also need the external + library protobuf-java, which you can download manually from the official + Maven repository and add it to the CLASSPATH, or use Maven's automatic + dependency resolution features by adding a dependency to "GroupId: mysql" + and "ArtifactId: mysql-connector-java" to your project's pom.xml file. diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/build.xml b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/build.xml new file mode 100644 index 0000000..96c8a0c --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/build.xml @@ -0,0 +1,1591 @@ + + + + +Compiling Connector/J +===================== + +Connector/J 8.0 supports JDBC4.2 and implements the X DevAPI. This requires JDBC classes to be compiled with Java 8. +The variable 'com.mysql.cj.build.jdk' is used to find the compiler when building the driver. Side by side with these, the variable 'com.mysql.cj.extra.libs' +must point to the location of third-party libraries that we don't distribute and are required for compiling. Further details can be found in +http://dev.mysql.com/doc/connector-j/en/connector-j-installing-source.html. + +Targets: "dist", "full-dist", "package", "full-package", "full-package-no-sources", "compile", "install" + + +Testing Connector/J +=================== + +Connector/J 8.0 ships with an extensive test suite that can be run simply by providing a MySQL JDBC URL in the variable 'com.mysql.cj.testsuite.url' and by +calling the target "test". If nothing more is set, these tests run with the JVM referred in the variable 'com.mysql.cj.build.jdk'. +Alternatively, all tests can be run with a distinct JVM, provided that it is pointed out in the variable 'com.mysql.cj.testsuite.jvm'. +Running only one test set is possible by setting the variable 'com.mysql.cj.testsuite.test.class' with the class' fully qualified name. If also a comma +separated list of test names is provided in the variable 'com.mysql.cj.testsuite.test.methods', then only these will be executed. + +Targets: "test" + + +Coverage and instrumentation +============================ + +This file ships with target "test-coverage" for collecting coverage results and "report-coverage" for creating the HTML coverage report. +The JaCoCo library needed to run these targets can be found at https://github.com/jacoco/jacoco, its JARs should be placed +into ${com.mysql.cj.extra.libs}/jacoco directory. +The "test-coverage" target enables tests execution-time JaCoCo instrumentation, runs tests collecting coverage info into result file +which path is set as ${com.mysql.cj.coverage.result.dir}/${com.mysql.cj.coverage.result.name}. +The "report-coverage" target first merges coverage result files which are placed in 'com.mysql.cj.coverage.result.dir' directory and +their comma-delimited names are passed via 'com.mysql.cj.coverage.merge.files' property. Merge result file path is passed +via 'com.mysql.cj.coverage.merge.result' property. Finally this target builds the HTML report from +'com.mysql.cj.coverage.merge.result' file into the directory passed via 'com.mysql.cj.coverage.report.dir' property. +If some properties are not passed to ANT script then default values are used: + com.mysql.cj.coverage.result.dir - "${com.mysql.cj.testsuite.build.dir}/coverage" + com.mysql.cj.coverage.result.name - "jacoco.exec" + com.mysql.cj.coverage.merge.files - none, merge step is skipped + com.mysql.cj.coverage.merge.result - ${com.mysql.cj.coverage.result.dir}/jacoco.exec + com.mysql.cj.coverage.report.dir - ${com.mysql.cj.coverage.result.dir}/report + +Targets: "test-coverage", "report-coverage" + + +Generate X DevAPI reference documentation +========================================= + +The target "xdevapi-docs" generates the Javadocs for the X DevAPI classes. The property "com.mysql.cj.docs.xdevapi" can be used to set the destination of the +Javadoc HTML files. + +Targets: "xdevapi-docs" + + +Sample 'build.properties' that can be used to compile, build and test +===================================================================== +~~~start cut here~~~ +# Basic settings for 'compile', 'test' and targets that depend on these. + +# External libraries needed for both compiling and testing: +# - Further details in http://dev.mysql.com/doc/connector-j/en/connector-j-installing-source.html +# - Mandatory. +com.mysql.cj.extra.libs=<full_path_to_connector-j-jardeps> + +# JDKs needed for compiling: +# - Must point to JDK home directory. +# - Also used for testing if 'com.mysql.cj.testsuite.jvm' is not provided. +# - Mandatory. +com.mysql.cj.build.jdk=<full_path_to_jdk1.8> + +# Single JVM/MySQL tests: +# - Must point to JDK or JRE home directory. +# - If not provided, JDBC tests are run with 'com.mysql.cj.build.jdk'. +# - Optional. +com.mysql.cj.testsuite.jvm=<full_path_to_a_jdk_or_jre> +# - URL to the test database. +# - Any of the current MySQL versions. +# - Mandatory for 'test' target. +com.mysql.cj.testsuite.url=jdbc:mysql://<host>:<port>/<testDB>?user=<user>&password=<pwd> +com.mysql.cj.testsuite.mysqlx.url=jdbc:mysql://<user>:<pwd>@<host>:<port>/<testDB> + +# Cancels re-compiling between successive test executions. +# - Comment variable if not needed. +# - Optional. +com.mysql.cj.build.noCleanBetweenCompiles=yes + +# Other targets may require specific settings. Check 'build.xml' for details. +~~~end cut here~~~ + + +Available build properties +========================== + +build.properties - path to properties file + +com.mysql.cj.extra.libs - location of third-party libraries: [${com.mysql.cj.extra.libs}] + +com.mysql.cj.build.jdk - path to JDK used for building driver: [${com.mysql.cj.build.jdk}] +com.mysql.cj.build.addDebugInfo - should the driver be compiled with debugging info: [${com.mysql.cj.build.addDebugInfo}] +com.mysql.cj.build.noCleanBetweenCompiles - don't clean artifacts from previous build: [_unset_] +com.mysql.cj.build.failOnWarnings - fail the build when any warning is found: [_unset_] +com.mysql.cj.build.verbose - log the extended build info: [_unset_] + +com.mysql.cj.build.commercial - build commercial variant of the driver: [_unset_] +com.mysql.cj.build.filterLicense - build ISV variant of the driver: [_unset_] +com.mysql.cj.build.noCrypto - build the driver without SSL support: [_unset_] + +com.mysql.cj.build.driver.version.major - major version: [${com.mysql.cj.build.driver.version.major}] +com.mysql.cj.build.driver.version.minor - minor version: [${com.mysql.cj.build.driver.version.minor}] +com.mysql.cj.build.driver.version.subminor - subminor version: [${com.mysql.cj.build.driver.version.subminor}] +com.mysql.cj.build.driver.version.status - version status, such as '-rc' or '-dmr': [${com.mysql.cj.build.driver.version.status}] + +com.mysql.cj.build.driver.version - standard version string (includes version status): [${com.mysql.cj.build.driver.version.numeric}${com.mysql.cj.build.driver.version.status}] +com.mysql.cj.build.driver.version.series - product series, i.e. x.y: [${com.mysql.cj.build.driver.version.major}.${com.mysql.cj.build.driver.version.minor}] +com.mysql.cj.build.driver.version.numeric - numeric version, i.e. x.y.z: [${com.mysql.cj.build.driver.version.series}.${com.mysql.cj.build.driver.version.subminor}} +com.mysql.cj.build.driver.version.extra - optional version information appended to the full version string: [${com.mysql.cj.build.driver.version.extra}] +com.mysql.cj.build.driver.version.snapshot - optional version snapshot marker: [${com.mysql.cj.build.driver.version.snapshot}] +com.mysql.cj.build.driver.version.full - full version string: [${com.mysql.cj.build.driver.version}${com.mysql.cj.build.driver.version.extra}${com.mysql.cj.build.driver.version.snapshot}] + +com.mysql.cj.build.driver.displayName - product display name: [${com.mysql.cj.build.driver.displayName}] +com.mysql.cj.build.driver.name - product name: [${com.mysql.cj.build.driver.name}] +com.mysql.cj.build.driver.extraName - optional extension to product name: [${com.mysql.cj.build.driver.extraName}] +com.mysql.cj.build.driver.extendedName - final product name: [${com.mysql.cj.build.driver.name}${com.mysql.cj.build.driver.extraName}] +com.mysql.cj.build.driver.fullName - full product name (includes version): [${com.mysql.cj.build.driver.extendedName}-${com.mysql.cj.build.driver.version.full}] + +com.mysql.cj.build.dir - root directory for driver build: [${com.mysql.cj.build.dir}] +com.mysql.cj.build.dir.driver - driver build dir: [${com.mysql.cj.build.dir}/${com.mysql.cj.build.driver.fullName}] + +com.mysql.cj.dist.packageName - final package name: [${com.mysql.cj.build.driver.extendedName}[${com.mysql.cj.dist.packageWithSourcesSuffix}|${com.mysql.cj.dist.packageNoSourcesSuffix}|_none_]-${com.mysql.cj.build.driver.version.full}] +com.mysql.cj.dist.packageSuffix - suffix added to package name (depends on package type): [${com.mysql.cj.dist.packageWithSourcesSuffix}|${com.mysql.cj.dist.packageNoSourcesSuffix}|_unset_] +com.mysql.cj.dist.packageWithSourcesSuffix - suffix for packages containing sources if not by default: [${com.mysql.cj.dist.packageWithSourcesSuffix}] +com.mysql.cj.dist.packageNoSourcesSuffix - suffix for packages not containing sources if not by default: [${com.mysql.cj.dist.packageNoSourcesSuffix}] +com.mysql.cj.dist.noSources - don't include sources into dist packages: [_unset] +com.mysql.cj.dist.noMavenSources - don't include sources into Maven package: [_unset_] +com.mysql.cj.dist.licenseUrl - license book location: [${com.mysql.cj.dist.licenseUrl}] + +com.mysql.cj.dist.dir - root directory for driver packaging: [${com.mysql.cj.dist.dir}] +com.mysql.cj.dist.dir.prepare - directory for preparing packages: [${com.mysql.cj.dist.dir.prepare}] +com.mysql.cj.dist.dir.package - directory for preparing packages for given package name: [${com.mysql.cj.dist.dir.prepare}/${com.mysql.cj.build.driver.extendedName}[${com.mysql.cj.dist.packageWithSourcesSuffix}|${com.mysql.cj.dist.packageNoSourcesSuffix}|_none_]-${com.mysql.cj.build.driver.version.full}] +com.mysql.cj.dist.dir.maven - directory for preparing Maven packages: [${com.mysql.cj.dist.dir.prepare}/${com.mysql.cj.build.driver.extendedName}[${com.mysql.cj.dist.packageWithSourcesSuffix}|${com.mysql.cj.dist.packageNoSourcesSuffix}|_none_]-${com.mysql.cj.build.driver.version.full}-maven-bundle] +com.mysql.cj.dist.dir.prebuilt.docs - where to take prebuilt documentation files for adding them to packages: [${com.mysql.cj.dist.dir.prebuilt.docs}] + +com.mysql.cj.dist.deb.maintainerEmail - the deb package maintainer email: [${com.mysql.cj.dist.deb.maintainerEmail}] + +com.mysql.cj.docs.xdevapi - destination of the X DevAPI Javadoc HTML files.: [docs] + +Available test properties +========================= + +com.mysql.cj.testsuite.build.dir - root directory for building testsuite, default '${com.mysql.cj.testsuite.build.dir}' +com.mysql.cj.testsuite.junit.results - where to put junit reports, default '${com.mysql.cj.testsuite.junit.results}' +com.mysql.cj.testsuite.jvm - run testsuite under this one JVM, default '${com.mysql.cj.testsuite.jvm}' +com.mysql.cj.testsuite.url - connection string to the main test server, default _unset_ +com.mysql.cj.testsuite.url.openssl - connection string to the test server compiled with OpenSSL, used in sha256 tests, default _unset_ +com.mysql.cj.testsuite.mysqlx.url - connection string to the test server with xplugin, default _unset_ +com.mysql.cj.testsuite.mysqlx.url.openssl - connection string to the test server compiled with OpenSSL and enabled xplugin, default _unset_ +com.mysql.cj.testsuite.test.class - testcase class name to run, default _unset_ +com.mysql.cj.testsuite.test.methods - a comma separated list of test names existing in class defined by 'com.mysql.cj.testsuite.test.class', default _unset_ +com.mysql.cj.testsuite.unavailable.host - a host:port pair used for tests checking socket connection timeout +com.mysql.cj.testsuite.no.server.testsuite - Option to indicate that the server was installed without the test package, default _unset_ + +See also com.mysql.cj.conf.PropertyDefinitions.SYSP_* variables for other test options. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + build-date: ${com.mysql.cj.build.time}${line.separator} + os-info: ${os.name} ${os.arch} ${os.version}${line.separator} + compiler: ${com.mysql.cj.dist.jdk.compilerVersion}${line.separator} + build-tool: ${ant.version}${line.separator} + + + ## INFO_BIN ##${line.separator}${com.mysql.cj.build.infoBinFromFile} + + + version: ${com.mysql.cj.build.driver.version.full}${line.separator} + branch: ${com.mysql.cj.build.git.branch}${line.separator} + date: ${com.mysql.cj.build.git.date}${line.separator} + commit: ${com.mysql.cj.build.git.commit}${line.separator} + short: ${com.mysql.cj.build.git.short}${line.separator} + + + ## INFO_SRC ##${line.separator}${com.mysql.cj.build.infoSrcFromFile} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Removing sources from '${com.mysql.cj.dist.dir.prepare}' + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Compiling MySQL Connector/J JDBC implementation with '${com.mysql.cj.build.jdk}' to '${com.mysql.cj.build.compiler.output}' + + + + + + + + + + + + + + + + + + + + + + + + + + Compiling MySQL Connector/J testsuite with '${com.mysql.cj.build.jdk}' to '${com.mysql.cj.testsuite.compiler.output}' + + + + + + + + + + + + + + + Compiling MySQL Connector/J-c3p0 integration with '${com.mysql.cj.build.jdk}' to '${com.mysql.cj.build.compiler.output}' + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + ${com.mysql.cj.testsuite.message.test.mode} + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Using Commercial settings + + + + + + + + Using GPL settings + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/java/documentation/ErrorMappingsDocGenerator.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/java/documentation/ErrorMappingsDocGenerator.java new file mode 100644 index 0000000..a6a0a2e --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/java/documentation/ErrorMappingsDocGenerator.java @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package documentation; + +import java.util.HashMap; +import java.util.Map; +import java.util.TreeMap; + +import com.mysql.cj.exceptions.MysqlErrorNumbers; + +/** + * Creates XML file describing mapping of MySQL error #'s to SQL92 and X/Open states. + */ +public class ErrorMappingsDocGenerator { + + public static void main(String[] args) throws Exception { + dumpSqlStatesMappingsAsXml(); + } + + public static void dumpSqlStatesMappingsAsXml() throws Exception { + TreeMap allErrorNumbers = new TreeMap<>(); + Map mysqlErrorNumbersToNames = new HashMap<>(); + + // Integer errorNumber = null; + + // + // First create a list of all 'known' error numbers that are mapped. + // + for (Integer errorNumber : MysqlErrorNumbers.mysqlToSql99State.keySet()) { + allErrorNumbers.put(errorNumber, errorNumber); + } + + // + // Now create a list of the actual MySQL error numbers we know about + // + java.lang.reflect.Field[] possibleFields = MysqlErrorNumbers.class.getDeclaredFields(); + + for (int i = 0; i < possibleFields.length; i++) { + String fieldName = possibleFields[i].getName(); + + if (fieldName.startsWith("ER_")) { + mysqlErrorNumbersToNames.put(possibleFields[i].get(null), fieldName); + } + } + + System.out.println(""); + + for (Integer errorNumber : allErrorNumbers.keySet()) { + String sql92State = MysqlErrorNumbers.mysqlToSql99(errorNumber.intValue()); + + System.out.println(" "); + } + + System.out.println(""); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/java/documentation/PropertiesDocGenerator.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/java/documentation/PropertiesDocGenerator.java new file mode 100644 index 0000000..cbe37eb --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/java/documentation/PropertiesDocGenerator.java @@ -0,0 +1,143 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package documentation; + +import java.util.HashMap; +import java.util.Map; +import java.util.TreeMap; + +import com.mysql.cj.conf.PropertyDefinition; +import com.mysql.cj.conf.PropertyDefinitions; + +/** + * Creates docbook table of connection properties from ConnectionProperties class. + */ +public class PropertiesDocGenerator { + + public static void main(String[] args) { + System.out.println(exposeAsXml()); + } + + static class XmlMap { + protected Map>> ordered = new TreeMap<>(); + protected Map> alpha = new TreeMap<>(); + } + + /** + * Returns a description of the connection properties as an XML document. + * + * @return the connection properties as an XML document. + */ + public static String exposeAsXml() { + StringBuilder xmlBuf = new StringBuilder(); + xmlBuf.append(""); + + int numCategories = PropertyDefinitions.PROPERTY_CATEGORIES.length; + + Map propertyListByCategory = new HashMap<>(); + + for (int i = 0; i < numCategories; i++) { + propertyListByCategory.put(PropertyDefinitions.PROPERTY_CATEGORIES[i], new XmlMap()); + } + + for (PropertyDefinition pdef : PropertyDefinitions.PROPERTY_KEY_TO_PROPERTY_DEFINITION.values()) { + XmlMap sortMaps = propertyListByCategory.get(pdef.getCategory()); + int orderInCategory = pdef.getOrder(); + + if (orderInCategory == Integer.MIN_VALUE) { + sortMaps.alpha.put(pdef.getName(), pdef); + } else { + Integer order = Integer.valueOf(orderInCategory); + Map> orderMap = sortMaps.ordered.get(order); + + if (orderMap == null) { + orderMap = new TreeMap<>(); + sortMaps.ordered.put(order, orderMap); + } + + orderMap.put(pdef.getName(), pdef); + } + } + + for (int j = 0; j < numCategories; j++) { + XmlMap sortMaps = propertyListByCategory.get(PropertyDefinitions.PROPERTY_CATEGORIES[j]); + + xmlBuf.append("\n "); + + for (Map> orderedEl : sortMaps.ordered.values()) { + for (PropertyDefinition pdef : orderedEl.values()) { + xmlBuf.append("\n \n"); + xmlBuf.append(" "); + String escapedDescription = pdef.getDescription(); + escapedDescription = escapedDescription.replace("&", "&").replace("<", "<").replace(">", ">"); + + xmlBuf.append(escapedDescription); + xmlBuf.append("\n "); + } + } + + for (PropertyDefinition pdef : sortMaps.alpha.values()) { + xmlBuf.append("\n \n"); + xmlBuf.append(" "); + xmlBuf.append(pdef.getDescription()); + xmlBuf.append("\n "); + } + + xmlBuf.append("\n "); + } + + xmlBuf.append("\n"); + + return xmlBuf.toString(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/java/instrumentation/AddMethods.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/java/instrumentation/AddMethods.java new file mode 100644 index 0000000..740b9f9 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/java/instrumentation/AddMethods.java @@ -0,0 +1,139 @@ +/* + * Copyright (c) 2017, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package instrumentation; + +import java.util.Collection; + +import com.mysql.cj.conf.BooleanPropertyDefinition; +import com.mysql.cj.conf.EnumPropertyDefinition; +import com.mysql.cj.conf.IntegerPropertyDefinition; +import com.mysql.cj.conf.LongPropertyDefinition; +import com.mysql.cj.conf.MemorySizePropertyDefinition; +import com.mysql.cj.conf.PropertyDefinition; +import com.mysql.cj.conf.PropertyDefinitions; +import com.mysql.cj.conf.StringPropertyDefinition; +import com.mysql.cj.jdbc.MysqlDataSource; + +import javassist.ClassPool; +import javassist.CtClass; +import javassist.CtMethod; +import javassist.CtNewMethod; +import javassist.bytecode.DuplicateMemberException; + +public class AddMethods { + private static boolean verbose = false; + + public static void main(String[] args) throws Exception { + + System.out.println("Applying AddMethods."); + + verbose = "true".equalsIgnoreCase(args[1]); + + ClassPool pool = ClassPool.getDefault(); + pool.insertClassPath(args[0]); + + sysOut("---"); + CtClass clazz = pool.get(MysqlDataSource.class.getName()); + sysOut("Add properties setters/getters to " + clazz.getName()); + addPropertiesGettersSetters(clazz, PropertyDefinitions.PROPERTY_KEY_TO_PROPERTY_DEFINITION.values()); + clazz.writeFile(args[0]); + + } + + private static void sysOut(String s) { + if (verbose) { + System.out.println(s); + } + } + + private static void addPropertiesGettersSetters(CtClass clazz, Collection> propertyDefinitions) throws Exception { + for (PropertyDefinition def : propertyDefinitions) { + if (def.getCategory().equals(PropertyDefinitions.CATEGORY_XDEVAPI)) { + continue; + } + String pname = def.hasCcAlias() ? def.getCcAlias() : def.getName(); + + if (def instanceof StringPropertyDefinition) { + addGetter(clazz, pname, String.class.getName(), "getStringRuntimeProperty"); + addSetter(clazz, pname, String.class.getName(), "setStringRuntimeProperty"); + + } else if (def instanceof BooleanPropertyDefinition) { + addGetter(clazz, pname, Boolean.TYPE.getName(), "getBooleanRuntimeProperty"); + addSetter(clazz, pname, Boolean.TYPE.getName(), "setBooleanRuntimeProperty"); + + } else if (def instanceof IntegerPropertyDefinition) { + addGetter(clazz, pname, Integer.TYPE.getName(), "getIntegerRuntimeProperty"); + addSetter(clazz, pname, Integer.TYPE.getName(), "setIntegerRuntimeProperty"); + + } else if (def instanceof LongPropertyDefinition) { + addGetter(clazz, pname, Long.TYPE.getName(), "getLongRuntimeProperty"); + addSetter(clazz, pname, Long.TYPE.getName(), "setLongRuntimeProperty"); + + } else if (def instanceof MemorySizePropertyDefinition) { + addGetter(clazz, pname, Integer.TYPE.getName(), "getMemorySizeRuntimeProperty"); + addSetter(clazz, pname, Integer.TYPE.getName(), "setMemorySizeRuntimeProperty"); + + } else if (def instanceof EnumPropertyDefinition) { + addGetter(clazz, pname, String.class.getName(), "getEnumRuntimeProperty"); + addSetter(clazz, pname, "java.lang.String", "setEnumRuntimeProperty"); + + } else { + throw new Exception("Unknown " + def.getName() + " property type."); + } + } + } + + private static void addGetter(CtClass clazz, String pname, String paramType, String getPropertyMethod) throws Exception { + String mname = "get" + pname.substring(0, 1).toUpperCase() + pname.substring(1); + String mbody = "public " + paramType + " " + mname + "() throws java.sql.SQLException { return " + getPropertyMethod + "(\"" + pname + "\");}"; + sysOut(mbody); + try { + CtMethod m = CtNewMethod.make(mbody, clazz); + clazz.addMethod(m); + sysOut(m.toString()); + } catch (DuplicateMemberException ex) { + // ignore + } + } + + private static void addSetter(CtClass clazz, String pname, String paramType, String setPropertyMethod) throws Exception { + String mname = "set" + pname.substring(0, 1).toUpperCase() + pname.substring(1); + String mbody = "public void " + mname + "(" + paramType + " value) throws java.sql.SQLException { " + setPropertyMethod + "(\"" + pname + + "\", value);}"; + sysOut(mbody); + try { + CtMethod m = CtNewMethod.make(mbody, clazz); + clazz.addMethod(m); + sysOut(m.toString()); + } catch (DuplicateMemberException ex) { + // ignore + } + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/java/instrumentation/CommonChecks.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/java/instrumentation/CommonChecks.java new file mode 100644 index 0000000..8d25a7b --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/java/instrumentation/CommonChecks.java @@ -0,0 +1,193 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package instrumentation; + +import java.sql.Savepoint; +import java.util.Map; + +import com.mysql.cj.jdbc.ConnectionImpl; +import com.mysql.cj.jdbc.ConnectionWrapper; + +import javassist.ClassPool; +import javassist.CtClass; +import javassist.CtMethod; + +public class CommonChecks { + private static boolean verbose = false; + + public static void main(String[] args) throws Exception { + + System.out.println("Applying CommonChecks."); + + verbose = "true".equalsIgnoreCase(args[1]); + + ClassPool pool = ClassPool.getDefault(); + pool.insertClassPath(args[0]); + + // params classes + CtClass ctClazz = pool.get(Class.class.getName()); + //CtClass ctClob = pool.get(java.sql.Clob.class.getName()); + //CtClass ctBindValue = pool.get(BindValue.class.getName()); + CtClass ctBool = pool.get(boolean.class.getName()); + //CtClass ctBoolArray = pool.get(boolean[].class.getName()); + //CtClass ctByteArray2 = pool.get(byte[][].class.getName()); + //CtClass ctBuffer = pool.get(Buffer.class.getName()); + //CtClass ctExecutor = pool.get(Executor.class.getName()); + //CtClass ctFieldArray = pool.get(Field[].class.getName()); + CtClass ctInt = pool.get(int.class.getName()); + CtClass ctIntArray = pool.get(int[].class.getName()); + //CtClass ctInputStreamArray = pool.get(InputStream[].class.getName()); + //CtClass ctLong = pool.get(long.class.getName()); + CtClass ctMap = pool.get(Map.class.getName()); + //CtClass ctMysqlSavepoint = pool.get(MysqlSavepoint.class.getName()); + CtClass ctObjectArray = pool.get(Object[].class.getName()); + //CtClass ctProperties = pool.get(Properties.class.getName()); + //CtClass ctReader = pool.get(Reader.class.getName()); + CtClass ctSavepoint = pool.get(Savepoint.class.getName()); + //CtClass ctStatement = pool.get(Statement.class.getName()); + CtClass ctString = pool.get(String.class.getName()); + CtClass ctStringArray = pool.get(String[].class.getName()); + + CtClass clazz = pool.get(ConnectionImpl.class.getName()); + // addClosedCheck(clazz.getDeclaredMethod("changeUser", new CtClass[] { ctString, ctString })); + addClosedCheck(clazz.getDeclaredMethod("clientPrepareStatement", new CtClass[] { ctString, ctInt, ctInt, ctBool })); + // addClosedCheck(clazz.getDeclaredMethod("commit", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("createStatement", new CtClass[] { ctInt, ctInt })); + // addClosedCheck(clazz.getDeclaredMethod("getMetaData", new CtClass[] { ctBool, ctBool })); + // addClosedCheck(clazz.getDeclaredMethod("getNetworkTimeout", new CtClass[] {})); + // addClosedCheck(clazz.getDeclaredMethod("getSchema", new CtClass[] {})); + // addClosedCheck(clazz.getDeclaredMethod("isAutoCommitNonDefaultOnServer", new CtClass[] {})); + // addClosedCheck(clazz.getDeclaredMethod("isServerLocal", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("isWrapperFor", new CtClass[] { ctClazz })); + // addClosedCheck(clazz.getDeclaredMethod("prepareStatement", new CtClass[] { ctString, ctInt, ctInt })); + // addClosedCheck(clazz.getDeclaredMethod("rollback", new CtClass[] {})); + // addClosedCheck(clazz.getDeclaredMethod("rollback", new CtClass[] { ctSavepoint })); + // addClosedCheck(clazz.getDeclaredMethod("setAutoCommit", new CtClass[] { ctBool })); + // addClosedCheck(clazz.getDeclaredMethod("setCatalog", new CtClass[] { ctString })); + // addClosedCheck(clazz.getDeclaredMethod("setNetworkTimeout", new CtClass[] { ctExecutor, ctInt })); + addClosedCheck(clazz.getDeclaredMethod("setReadOnly", new CtClass[] { ctBool })); + // addClosedCheck(clazz.getDeclaredMethod("setSavepoint", new CtClass[] { ctMysqlSavepoint })); + // addClosedCheck(clazz.getDeclaredMethod("setSchema", new CtClass[] { ctString })); + // addClosedCheck(clazz.getDeclaredMethod("setTransactionIsolation", new CtClass[] { ctInt })); + addClosedCheck(clazz.getDeclaredMethod("versionMeetsMinimum", new CtClass[] { ctInt, ctInt, ctInt })); + clazz.writeFile(args[0]); + + clazz = pool.get(ConnectionWrapper.class.getName()); + addClosedCheck(clazz.getDeclaredMethod("changeUser", new CtClass[] { ctString, ctString })); + addClosedCheck(clazz.getDeclaredMethod("clientPrepare", new CtClass[] { ctString })); + addClosedCheck(clazz.getDeclaredMethod("clientPrepare", new CtClass[] { ctString, ctInt, ctInt })); + addClosedCheck(clazz.getDeclaredMethod("clientPrepareStatement", new CtClass[] { ctString })); + addClosedCheck(clazz.getDeclaredMethod("clientPrepareStatement", new CtClass[] { ctString, ctInt })); + addClosedCheck(clazz.getDeclaredMethod("clientPrepareStatement", new CtClass[] { ctString, ctIntArray })); + addClosedCheck(clazz.getDeclaredMethod("clientPrepareStatement", new CtClass[] { ctString, ctStringArray })); + addClosedCheck(clazz.getDeclaredMethod("clientPrepareStatement", new CtClass[] { ctString, ctInt, ctInt })); + addClosedCheck(clazz.getDeclaredMethod("clientPrepareStatement", new CtClass[] { ctString, ctInt, ctInt, ctInt })); + addClosedCheck(clazz.getDeclaredMethod("commit", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("clearWarnings", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("createArrayOf", new CtClass[] { ctString, ctObjectArray })); + addClosedCheck(clazz.getDeclaredMethod("createBlob", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("createClob", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("createNClob", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("createStatement", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("createStatement", new CtClass[] { ctInt, ctInt })); + addClosedCheck(clazz.getDeclaredMethod("createStatement", new CtClass[] { ctInt, ctInt, ctInt })); + addClosedCheck(clazz.getDeclaredMethod("createSQLXML", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("createStruct", new CtClass[] { ctString, ctObjectArray })); + addClosedCheck(clazz.getDeclaredMethod("getAutoCommit", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("getCatalog", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("getClientInfo", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("getClientInfo", new CtClass[] { ctString })); + addClosedCheck(clazz.getDeclaredMethod("getDatabase", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("getHoldability", new CtClass[] {})); + // addClosedCheck(clazz.getDeclaredMethod("getProcessHost", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("getMetaData", new CtClass[] {})); + // addClosedCheck(clazz.getDeclaredMethod("getNetworkTimeout", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("getTransactionIsolation", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("getTypeMap", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("getWarnings", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("isReadOnly", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("isReadOnly", new CtClass[] { ctBool })); + //addClosedCheck(clazz.getDeclaredMethod("isWrapperFor", new CtClass[] { ctClazz })); + addClosedCheck(clazz.getDeclaredMethod("nativeSQL", new CtClass[] { ctString })); + addClosedCheck(clazz.getDeclaredMethod("prepareCall", new CtClass[] { ctString })); + addClosedCheck(clazz.getDeclaredMethod("prepareCall", new CtClass[] { ctString, ctInt, ctInt })); + addClosedCheck(clazz.getDeclaredMethod("prepareCall", new CtClass[] { ctString, ctInt, ctInt, ctInt })); + addClosedCheck(clazz.getDeclaredMethod("prepareStatement", new CtClass[] { ctString })); + addClosedCheck(clazz.getDeclaredMethod("prepareStatement", new CtClass[] { ctString, ctInt })); + // addClosedCheck(clazz.getDeclaredMethod("prepareStatement", new CtClass[] { ctString, ctStringArray })); + addClosedCheck(clazz.getDeclaredMethod("prepareStatement", new CtClass[] { ctString, ctIntArray })); + addClosedCheck(clazz.getDeclaredMethod("prepareStatement", new CtClass[] { ctString, ctInt, ctInt })); + addClosedCheck(clazz.getDeclaredMethod("prepareStatement", new CtClass[] { ctString, ctInt, ctInt, ctInt })); + addClosedCheck(clazz.getDeclaredMethod("prepareStatement", new CtClass[] { ctString, ctStringArray })); + addClosedCheck(clazz.getDeclaredMethod("releaseSavepoint", new CtClass[] { ctSavepoint })); + addClosedCheck(clazz.getDeclaredMethod("resetServerState", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("rollback", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("rollback", new CtClass[] { ctSavepoint })); + addClosedCheck(clazz.getDeclaredMethod("serverPrepareStatement", new CtClass[] { ctString })); + addClosedCheck(clazz.getDeclaredMethod("serverPrepareStatement", new CtClass[] { ctString, ctInt })); + addClosedCheck(clazz.getDeclaredMethod("serverPrepareStatement", new CtClass[] { ctString, ctIntArray })); + addClosedCheck(clazz.getDeclaredMethod("serverPrepareStatement", new CtClass[] { ctString, ctStringArray })); + addClosedCheck(clazz.getDeclaredMethod("serverPrepareStatement", new CtClass[] { ctString, ctInt, ctInt })); + addClosedCheck(clazz.getDeclaredMethod("serverPrepareStatement", new CtClass[] { ctString, ctInt, ctInt, ctInt })); + addClosedCheck(clazz.getDeclaredMethod("setAutoCommit", new CtClass[] { ctBool })); + addClosedCheck(clazz.getDeclaredMethod("setCatalog", new CtClass[] { ctString })); + // addClosedCheck(clazz.getDeclaredMethod("setClientInfo", new CtClass[] { ctString, ctString })); + // addClosedCheck(clazz.getDeclaredMethod("setClientInfo", new CtClass[] { ctProperties })); + addClosedCheck(clazz.getDeclaredMethod("setDatabase", new CtClass[] { ctString })); + addClosedCheck(clazz.getDeclaredMethod("setHoldability", new CtClass[] { ctInt })); + // addClosedCheck(clazz.getDeclaredMethod("setNetworkTimeout", new CtClass[] { ctExecutor, ctInt })); + addClosedCheck(clazz.getDeclaredMethod("setReadOnly", new CtClass[] { ctBool })); + addClosedCheck(clazz.getDeclaredMethod("setSavepoint", new CtClass[] {})); + addClosedCheck(clazz.getDeclaredMethod("setSavepoint", new CtClass[] { ctString })); + addClosedCheck(clazz.getDeclaredMethod("setSchema", new CtClass[] { ctString })); + addClosedCheck(clazz.getDeclaredMethod("setTransactionIsolation", new CtClass[] { ctInt })); + addClosedCheck(clazz.getDeclaredMethod("setTypeMap", new CtClass[] { ctMap })); + addClosedCheck(clazz.getDeclaredMethod("shutdownServer", new CtClass[] {})); + //addClosedCheck(clazz.getDeclaredMethod("versionMeetsMinimum", new CtClass[] { ctInt, ctInt, ctInt })); + clazz.writeFile(args[0]); + + //clazz = pool.get(MultiHostMySQLConnection.class.getName()); + //addClosedCheck(clazz.getDeclaredMethod("isWrapperFor", new CtClass[] { ctClazz })); + //clazz.writeFile(args[0]); + + } + + private static void addClosedCheck(CtMethod m) throws Exception { + sysOut(m.toString()); + m.insertBefore("checkClosed();"); + } + + private static void sysOut(String s) { + if (verbose) { + System.out.println(s); + } + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/java/instrumentation/TranslateExceptions.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/java/instrumentation/TranslateExceptions.java new file mode 100644 index 0000000..6df6eac --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/java/instrumentation/TranslateExceptions.java @@ -0,0 +1,734 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package instrumentation; + +import java.lang.reflect.Method; +import java.sql.ResultSet; +import java.sql.SQLException; +import java.sql.Savepoint; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Properties; +import java.util.TreeMap; + +import com.mysql.cj.QueryBindings; +import com.mysql.cj.exceptions.CJException; +import com.mysql.cj.jdbc.Blob; +import com.mysql.cj.jdbc.BlobFromLocator; +import com.mysql.cj.jdbc.CallableStatement; +import com.mysql.cj.jdbc.CallableStatement.CallableStatementParamInfo; +import com.mysql.cj.jdbc.ClientPreparedStatement; +import com.mysql.cj.jdbc.Clob; +import com.mysql.cj.jdbc.ConnectionImpl; +import com.mysql.cj.jdbc.ConnectionWrapper; +import com.mysql.cj.jdbc.DatabaseMetaData; +import com.mysql.cj.jdbc.DatabaseMetaDataUsingInfoSchema; +import com.mysql.cj.jdbc.JdbcConnection; +import com.mysql.cj.jdbc.JdbcStatement; +import com.mysql.cj.jdbc.MysqlConnectionPoolDataSource; +import com.mysql.cj.jdbc.MysqlDataSource; +import com.mysql.cj.jdbc.MysqlParameterMetadata; +import com.mysql.cj.jdbc.MysqlPooledConnection; +import com.mysql.cj.jdbc.MysqlSQLXML; +import com.mysql.cj.jdbc.MysqlSavepoint; +import com.mysql.cj.jdbc.MysqlXAConnection; +import com.mysql.cj.jdbc.MysqlXADataSource; +import com.mysql.cj.jdbc.MysqlXid; +import com.mysql.cj.jdbc.NClob; +import com.mysql.cj.jdbc.NonRegisteringDriver; +import com.mysql.cj.jdbc.ServerPreparedStatement; +import com.mysql.cj.jdbc.StatementImpl; +import com.mysql.cj.jdbc.SuspendableXAConnection; +import com.mysql.cj.jdbc.exceptions.SQLExceptionsMapping; +import com.mysql.cj.jdbc.ha.LoadBalancedConnection; +import com.mysql.cj.jdbc.ha.LoadBalancedMySQLConnection; +import com.mysql.cj.jdbc.ha.MultiHostMySQLConnection; +import com.mysql.cj.jdbc.ha.ReplicationConnection; +import com.mysql.cj.jdbc.ha.ReplicationMySQLConnection; +import com.mysql.cj.jdbc.result.ResultSetImpl; +import com.mysql.cj.jdbc.result.ResultSetInternalMethods; +import com.mysql.cj.jdbc.result.ResultSetMetaData; +import com.mysql.cj.jdbc.result.UpdatableResultSet; +import com.mysql.cj.protocol.ColumnDefinition; +import com.mysql.cj.protocol.Message; + +import javassist.ClassPool; +import javassist.CtClass; +import javassist.CtMethod; +import javassist.NotFoundException; + +public class TranslateExceptions { + + private static CtClass runTimeException = null; + private static ClassPool pool = ClassPool.getDefault(); + private static Map> processed = new TreeMap<>(); + + private static String EXCEPTION_INTERCEPTOR_GETTER = "getExceptionInterceptor()"; + private static String EXCEPTION_INTERCEPTOR_MEMBER = "this.exceptionInterceptor"; + private static boolean verbose = false; + + public static void main(String[] args) throws Exception { + + System.out.println("Applying TranslateExceptions."); + + verbose = "true".equalsIgnoreCase(args[1]); + + pool.insertClassPath(args[0]); + processed.clear(); + + runTimeException = pool.get(CJException.class.getName()); + + // params classes + //CtClass ctServerPreparedQueryBindValue = pool.get(ServerPreparedQueryBindValue.class.getName()); + CtClass ctQueryBindings = pool.get(QueryBindings.class.getName()); + CtClass ctByteArray = pool.get(byte[].class.getName()); + CtClass ctColumnDefinition = pool.get(ColumnDefinition.class.getName()); + + CtClass ctLongArray = pool.get(long[].class.getName()); + //CtClass ctInputStream = pool.get(InputStream.class.getName()); + CtClass ctJdbcConnection = pool.get(JdbcConnection.class.getName()); + CtClass ctMysqlSavepoint = pool.get(MysqlSavepoint.class.getName()); + //CtClass ctPacketPayload = pool.get(PacketPayload.class.getName()); + CtClass ctProperties = pool.get(Properties.class.getName()); + CtClass ctResultSet = pool.get(ResultSet.class.getName()); + CtClass ctResultSetInternalMethods = pool.get(ResultSetInternalMethods.class.getName()); + CtClass ctStatement = pool.get(java.sql.Statement.class.getName()); + CtClass ctStatementImpl = pool.get(StatementImpl.class.getName()); + CtClass ctString = pool.get(String.class.getName()); + + CtClass ctMessageBody = pool.get(Message.class.getName()); + + // class we want to instrument + CtClass clazz; + + /* + * java.sql.Blob + */ + // com.mysql.cj.jdbc.Blob implements java.sql.Blob, OutputStreamWatcher + clazz = pool.get(Blob.class.getName()); + instrumentJdbcMethods(clazz, java.sql.Blob.class, false, EXCEPTION_INTERCEPTOR_MEMBER); + clazz.writeFile(args[0]); + + // com.mysql.cj.jdbc.BlobFromLocator implements java.sql.Blob + clazz = pool.get(BlobFromLocator.class.getName()); + instrumentJdbcMethods(clazz, java.sql.Blob.class, false, EXCEPTION_INTERCEPTOR_MEMBER); + clazz.writeFile(args[0]); + + /* + * java.sql.CallableStatement + */ + // com.mysql.cj.jdbc.CallableStatement extends PreparedStatement implements java.sql.CallableStatement + clazz = pool.get(CallableStatement.class.getName()); + instrumentJdbcMethods(clazz, java.sql.CallableStatement.class, false, EXCEPTION_INTERCEPTOR_GETTER); + instrumentJdbcMethods(clazz, JdbcStatement.class, true, EXCEPTION_INTERCEPTOR_GETTER); + // non-JDBC + catchRuntimeException(clazz, clazz.getDeclaredMethod("checkIsOutputParam", new CtClass[] { CtClass.intType }), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("checkParameterIndexBounds", new CtClass[] { CtClass.intType }), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("checkReadOnlyProcedure", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("convertGetProcedureColumnsToInternalDescriptors", new CtClass[] { ctResultSet }), + EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("determineParameterTypes", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("fakeParameterTypes", new CtClass[] { CtClass.booleanType }), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("fixParameterName", new CtClass[] { ctString }), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("generateParameterMap", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("getNamedParamIndex", new CtClass[] { ctString, CtClass.booleanType }), + EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("getOutputParameters", new CtClass[] { CtClass.intType }), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("mapOutputParameterIndexToRsIndex", new CtClass[] { CtClass.intType }), + EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("retrieveOutParams", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("setInOutParamsOnServer", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("setOutParams", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + clazz.writeFile(args[0]); + + /* + * com.mysql.cj.jdbc.StatementWrapper extends WrapperBase implements Statement + */ + // TODO: Does it's own typical exception wrapping, could be instrumented with different catch method + + /* + * com.mysql.cj.jdbc.PreparedStatementWrapper extends StatementWrapper implements PreparedStatement + */ + // TODO: Does it's own typical exception wrapping, could be instrumented with different catch method + + /* + * com.mysql.cj.jdbc.CallableStatementWrapper extends PreparedStatementWrapper implements CallableStatement + */ + // TODO: Does it's own typical exception wrapping, could be instrumented with different catch method + + /* + * java.sql.Clob + */ + // com.mysql.cj.jdbc.Clob implements java.sql.Clob, OutputStreamWatcher, WriterWatcher + clazz = pool.get(Clob.class.getName()); + instrumentJdbcMethods(clazz, java.sql.Clob.class, false, EXCEPTION_INTERCEPTOR_MEMBER); + clazz.writeFile(args[0]); + + /* + * + * java.sql.Connection extends java.sql.Wrapper + * ----> com.mysql.cj.jdbc.JdbcConnection extends java.sql.Connection, MysqlConnection + * ----------> com.mysql.cj.jdbc.ConnectionImpl + * ----------> com.mysql.cj.jdbc.LoadBalancedConnection extends JdbcConnection + * -------------> com.mysql.cj.jdbc.LoadBalancedMySQLConnection extends MultiHostMySQLConnection implements LoadBalancedConnection + * ----------> com.mysql.cj.jdbc.MultiHostMySQLConnection + * -------> com.mysql.cj.jdbc.ReplicationConnection implements JdbcConnection, PingTarget + * -------> com.mysql.cj.jdbc.ConnectionWrapper + */ + // ConnectionImpl extends AbstractJdbcConnection implements JdbcConnection + clazz = pool.get(ConnectionImpl.class.getName()); + instrumentJdbcMethods(clazz, JdbcConnection.class, false, EXCEPTION_INTERCEPTOR_GETTER); + // non-JDBC + catchRuntimeException(clazz, + clazz.getDeclaredMethod("clientPrepareStatement", new CtClass[] { ctString, CtClass.intType, CtClass.intType, CtClass.booleanType }), + EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("createNewIO", new CtClass[] { CtClass.booleanType }), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("getMetaData", new CtClass[] { CtClass.booleanType, CtClass.booleanType }), + EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("handleAutoCommitDefaults", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("setSavepoint", new CtClass[] { ctMysqlSavepoint }), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("versionMeetsMinimum", new CtClass[] { CtClass.intType, CtClass.intType, CtClass.intType }), + EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("rollbackNoChecks", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("setupServerForTruncationChecks", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + clazz.writeFile(args[0]); + + // com.mysql.cj.jdbc.LoadBalancedMySQLConnection extends MultiHostMySQLConnection implements LoadBalancedConnection + clazz = pool.get(LoadBalancedMySQLConnection.class.getName()); + instrumentJdbcMethods(clazz, LoadBalancedConnection.class, false, EXCEPTION_INTERCEPTOR_GETTER); + clazz.writeFile(args[0]); + + // MultiHostMySQLConnection implements JdbcConnection + clazz = pool.get(MultiHostMySQLConnection.class.getName()); + instrumentJdbcMethods(clazz, JdbcConnection.class, false, EXCEPTION_INTERCEPTOR_GETTER); + clazz.writeFile(args[0]); + + // com.mysql.cj.jdbc.ReplicationConnection implements JdbcConnection, PingTarget + clazz = pool.get(ReplicationMySQLConnection.class.getName()); + instrumentJdbcMethods(clazz, ReplicationConnection.class, false, EXCEPTION_INTERCEPTOR_GETTER); + clazz.writeFile(args[0]); + + // ConnectionWrapper extends WrapperBase implements JdbcConnection + clazz = pool.get(ConnectionWrapper.class.getName()); + instrumentJdbcMethods(clazz, JdbcConnection.class, false, EXCEPTION_INTERCEPTOR_MEMBER); + // non-JDBC + catchRuntimeException(clazz, clazz.getDeclaredMethod("clientPrepare", new CtClass[] { ctString }), EXCEPTION_INTERCEPTOR_MEMBER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("clientPrepare", new CtClass[] { ctString, CtClass.intType, CtClass.intType }), + EXCEPTION_INTERCEPTOR_MEMBER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("setClientInfo", new CtClass[] { ctString, ctString }), EXCEPTION_INTERCEPTOR_MEMBER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("setClientInfo", new CtClass[] { ctProperties }), EXCEPTION_INTERCEPTOR_MEMBER); + clazz.writeFile(args[0]); + + /* + * java.sql.DatabaseMetaData extends java.sql.Wrapper + */ + // com.mysql.cj.jdbc.DatabaseMetaData implements java.sql.DatabaseMetaData + clazz = pool.get(DatabaseMetaData.class.getName()); + instrumentJdbcMethods(clazz, java.sql.DatabaseMetaData.class, false, EXCEPTION_INTERCEPTOR_GETTER); + clazz.writeFile(args[0]); + + // com.mysql.cj.jdbc.DatabaseMetaDataUsingInfoSchema extends DatabaseMetaData + clazz = pool.get(DatabaseMetaDataUsingInfoSchema.class.getName()); + instrumentJdbcMethods(clazz, java.sql.DatabaseMetaData.class, false, EXCEPTION_INTERCEPTOR_GETTER); + clazz.writeFile(args[0]); + + /* + * java.sql.Driver + */ + // com.mysql.cj.jdbc.Driver extends NonRegisteringDriver implements java.sql.Driver + clazz = pool.get(NonRegisteringDriver.class.getName()); + instrumentJdbcMethods(clazz, java.sql.Driver.class); + clazz.writeFile(args[0]); + + /* + * java.sql.NClob + */ + // com.mysql.cj.jdbc.NClob extends Clob implements java.sql.NClob + clazz = pool.get(NClob.class.getName()); + instrumentJdbcMethods(clazz, java.sql.NClob.class); + clazz.writeFile(args[0]); + + /* + * java.sql.ParameterMetaData extends java.sql.Wrapper + */ + // com.mysql.cj.jdbc.CallableStatement.CallableStatementParamInfo implements ParameterMetaData + clazz = pool.get(CallableStatementParamInfo.class.getName()); + instrumentJdbcMethods(clazz, java.sql.ParameterMetaData.class); + clazz.writeFile(args[0]); + + // com.mysql.cj.jdbc.MysqlParameterMetadata implements ParameterMetaData + clazz = pool.get(MysqlParameterMetadata.class.getName()); + instrumentJdbcMethods(clazz, java.sql.ParameterMetaData.class, false, EXCEPTION_INTERCEPTOR_MEMBER); + clazz.writeFile(args[0]); + + /* + * java.sql.PreparedStatement extends java.sql.Statement (java.sql.Statement extends java.sql.Wrapper) + */ + // com.mysql.cj.jdbc.PreparedStatement extends com.mysql.cj.jdbc.StatementImpl implements java.sql.PreparedStatement + clazz = pool.get(ClientPreparedStatement.class.getName()); + instrumentJdbcMethods(clazz, java.sql.PreparedStatement.class, false, EXCEPTION_INTERCEPTOR_GETTER); + instrumentJdbcMethods(clazz, JdbcStatement.class, true, EXCEPTION_INTERCEPTOR_GETTER); + // non-JDBC + catchRuntimeException(clazz, clazz.getDeclaredMethod("asSql", new CtClass[] { CtClass.booleanType }), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("checkBounds", new CtClass[] { CtClass.intType, CtClass.intType }), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("checkReadOnlySafeStatement", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("executeBatchedInserts", new CtClass[] { CtClass.intType }), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("executeBatchSerially", new CtClass[] { CtClass.intType }), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, + clazz.getDeclaredMethod("executeInternal", + new CtClass[] { CtClass.intType, ctMessageBody, CtClass.booleanType, CtClass.booleanType, ctColumnDefinition, CtClass.booleanType }), + EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("executePreparedBatchAsMultiStatement", new CtClass[] { CtClass.intType }), + EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("executeUpdateInternal", new CtClass[] { CtClass.booleanType, CtClass.booleanType }), + EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("executeUpdateInternal", new CtClass[] { ctQueryBindings, CtClass.booleanType }), + EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("generateMultiStatementForBatch", new CtClass[] { CtClass.intType }), + EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("getBytesRepresentation", new CtClass[] { CtClass.intType }), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("getParameterBindings", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("initializeFromParseInfo", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("isNull", new CtClass[] { CtClass.intType }), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("isSelectQuery", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("prepareBatchedInsertSQL", new CtClass[] { ctJdbcConnection, CtClass.intType }), + EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, + clazz.getDeclaredMethod("setBytes", new CtClass[] { CtClass.intType, ctByteArray, CtClass.booleanType, CtClass.booleanType }), + EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("setRetrieveGeneratedKeys", new CtClass[] { CtClass.booleanType }), EXCEPTION_INTERCEPTOR_GETTER); + clazz.writeFile(args[0]); + + /* + * com.mysql.cj.jdbc.ServerPreparedStatement extends PreparedStatement + */ + clazz = pool.get(ServerPreparedStatement.class.getName()); + instrumentJdbcMethods(clazz, java.sql.PreparedStatement.class, false, EXCEPTION_INTERCEPTOR_GETTER); + instrumentJdbcMethods(clazz, JdbcStatement.class, true, EXCEPTION_INTERCEPTOR_GETTER); + // non-JDBC + catchRuntimeException(clazz, clazz.getDeclaredMethod("getBinding", new CtClass[] { CtClass.intType, CtClass.booleanType }), + EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, + clazz.getDeclaredMethod("executeInternal", + new CtClass[] { CtClass.intType, ctMessageBody, CtClass.booleanType, CtClass.booleanType, ctColumnDefinition, CtClass.booleanType }), + EXCEPTION_INTERCEPTOR_GETTER); + //catchRuntimeException(clazz, clazz.getDeclaredMethod("canRewriteAsMultiValueInsertAtSqlLevel", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("realClose", new CtClass[] { CtClass.booleanType, CtClass.booleanType }), + EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("serverExecute", new CtClass[] { CtClass.intType, CtClass.booleanType, ctColumnDefinition }), + EXCEPTION_INTERCEPTOR_GETTER); + //catchRuntimeException(clazz, clazz.getDeclaredMethod("serverLongData", new CtClass[] { CtClass.intType, ctServerPreparedQueryBindValue }), + // EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("serverPrepare", new CtClass[] { ctString }), EXCEPTION_INTERCEPTOR_GETTER); + clazz.writeFile(args[0]); + + /* + * java.sql.ResultSet extends java.sql.Wrapper + */ + // com.mysql.cj.jdbc.ResultSetImpl implements com.mysql.cj.jdbc.ResultSetInternalMethods (extends java.sql.ResultSet) + clazz = pool.get(ResultSetImpl.class.getName()); + instrumentJdbcMethods(clazz, ResultSetInternalMethods.class, false, EXCEPTION_INTERCEPTOR_GETTER); + clazz.writeFile(args[0]); + + // com.mysql.cj.jdbc.UpdatableResultSet extends ResultSetImpl + clazz = pool.get(UpdatableResultSet.class.getName()); + instrumentJdbcMethods(clazz, ResultSetInternalMethods.class, false, EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("generateStatements", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + clazz.writeFile(args[0]); + + /* + * java.sql.ResultSetMetaData extends java.sql.Wrapper + */ + // com.mysql.cj.jdbc.ResultSetMetaData implements java.sql.ResultSetMetaData + clazz = pool.get(ResultSetMetaData.class.getName()); + instrumentJdbcMethods(clazz, java.sql.ResultSetMetaData.class, false, EXCEPTION_INTERCEPTOR_MEMBER); + clazz.writeFile(args[0]); + + /* + * java.sql.Savepoint + */ + // com.mysql.cj.jdbc.MysqlSavepoint implements java.sql.Savepoint + clazz = pool.get(MysqlSavepoint.class.getName()); + instrumentJdbcMethods(clazz, Savepoint.class, false, EXCEPTION_INTERCEPTOR_MEMBER); + clazz.writeFile(args[0]); + + /* + * java.sql.Statement extends java.sql.Wrapper + */ + // com.mysql.cj.jdbc.StatementImpl implements com.mysql.cj.jdbc.Statement (extends java.sql.Statement) + clazz = pool.get(StatementImpl.class.getName()); + instrumentJdbcMethods(clazz, JdbcStatement.class, false, EXCEPTION_INTERCEPTOR_GETTER); + // non-JDBC + catchRuntimeException(clazz, clazz.getDeclaredMethod("createResultSetUsingServerFetch", new CtClass[] { ctString }), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("doPingInstead", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("executeInternal", new CtClass[] { ctString, CtClass.booleanType }), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, + clazz.getDeclaredMethod("executeBatchUsingMultiQueries", new CtClass[] { CtClass.booleanType, CtClass.intType, CtClass.intType }), + EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("executeUpdateInternal", new CtClass[] { ctString, CtClass.booleanType, CtClass.booleanType }), + EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("executeSimpleNonQuery", new CtClass[] { ctJdbcConnection, ctString }), + EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("generatePingResultSet", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("getBatchedGeneratedKeys", new CtClass[] { CtClass.intType }), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("getBatchedGeneratedKeys", new CtClass[] { ctStatement }), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("getGeneratedKeysInternal", new CtClass[] { CtClass.longType }), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("getLastInsertID", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("getLongUpdateCount", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("getOpenResultSetCount", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("getResultSetInternal", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("processMultiCountsAndKeys", new CtClass[] { ctStatementImpl, CtClass.intType, ctLongArray }), + EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("removeOpenResultSet", new CtClass[] { ctResultSetInternalMethods }), + EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("resetCancelledState", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("setHoldResultsOpenOverClose", new CtClass[] { CtClass.booleanType }), + EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("setResultSetConcurrency", new CtClass[] { CtClass.intType }), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("useServerFetch", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + catchRuntimeException(clazz, clazz.getDeclaredMethod("checkCancelTimeout", new CtClass[] {}), EXCEPTION_INTERCEPTOR_GETTER); + clazz.writeFile(args[0]); + + /* + * java.sql.SQLXML + */ + // com.mysql.cj.jdbc.MysqlSQLXML implements SQLXML + clazz = pool.get(MysqlSQLXML.class.getName()); + instrumentJdbcMethods(clazz, java.sql.SQLXML.class, false, EXCEPTION_INTERCEPTOR_MEMBER); + clazz.writeFile(args[0]); + + /* + * javax.sql.ConnectionPoolDataSource + */ + // MysqlConnectionPoolDataSource extends MysqlDataSource implements ConnectionPoolDataSource + clazz = pool.get(MysqlConnectionPoolDataSource.class.getName()); + instrumentJdbcMethods(clazz, javax.sql.ConnectionPoolDataSource.class); + clazz.writeFile(args[0]); + + /* + * javax.sql.DataSource + */ + // MysqlDataSource extends JdbcPropertySetImpl implements DataSource, Referenceable, Serializable, JdbcPropertySet + clazz = pool.get(MysqlDataSource.class.getName()); + instrumentJdbcMethods(clazz, javax.sql.DataSource.class); + catchRuntimeException(clazz, clazz.getDeclaredMethod("getStringRuntimeProperty", new CtClass[] { ctString }), null); + catchRuntimeException(clazz, clazz.getDeclaredMethod("setStringRuntimeProperty", new CtClass[] { ctString, ctString }), null); + catchRuntimeException(clazz, clazz.getDeclaredMethod("getBooleanRuntimeProperty", new CtClass[] { ctString }), null); + catchRuntimeException(clazz, clazz.getDeclaredMethod("setBooleanRuntimeProperty", new CtClass[] { ctString, CtClass.booleanType }), null); + catchRuntimeException(clazz, clazz.getDeclaredMethod("getIntegerRuntimeProperty", new CtClass[] { ctString }), null); + catchRuntimeException(clazz, clazz.getDeclaredMethod("setIntegerRuntimeProperty", new CtClass[] { ctString, CtClass.intType }), null); + catchRuntimeException(clazz, clazz.getDeclaredMethod("getLongRuntimeProperty", new CtClass[] { ctString }), null); + catchRuntimeException(clazz, clazz.getDeclaredMethod("setLongRuntimeProperty", new CtClass[] { ctString, CtClass.longType }), null); + catchRuntimeException(clazz, clazz.getDeclaredMethod("getMemorySizeRuntimeProperty", new CtClass[] { ctString }), null); + catchRuntimeException(clazz, clazz.getDeclaredMethod("setMemorySizeRuntimeProperty", new CtClass[] { ctString, CtClass.intType }), null); + catchRuntimeException(clazz, clazz.getDeclaredMethod("getEnumRuntimeProperty", new CtClass[] { ctString }), null); + catchRuntimeException(clazz, clazz.getDeclaredMethod("setEnumRuntimeProperty", new CtClass[] { ctString, ctString }), null); + clazz.writeFile(args[0]); + + /* + * javax.sql.PooledConnection + */ + // com.mysql.cj.jdbc.MysqlPooledConnection + clazz = pool.get(MysqlPooledConnection.class.getName()); + instrumentJdbcMethods(clazz, javax.sql.PooledConnection.class, false, EXCEPTION_INTERCEPTOR_MEMBER); + clazz.writeFile(args[0]); + + /* + * javax.sql.XAConnection + * javax.transaction.xa.XAResource + */ + // com.mysql.cj.jdbc.MysqlXAConnection extends MysqlPooledConnection implements XAConnection, XAResource + clazz = pool.get(MysqlXAConnection.class.getName()); + instrumentJdbcMethods(clazz, javax.sql.XAConnection.class); + clazz.writeFile(args[0]); + + // com.mysql.cj.jdbc.SuspendableXAConnection extends MysqlPooledConnection implements XAConnection, XAResource + clazz = pool.get(SuspendableXAConnection.class.getName()); + instrumentJdbcMethods(clazz, javax.sql.XAConnection.class); + clazz.writeFile(args[0]); + + /* + * javax.sql.XADataSource + */ + // com.mysql.cj.jdbc.MysqlXADataSource extends MysqlDataSource implements javax.sql.XADataSource + clazz = pool.get(MysqlXADataSource.class.getName()); + instrumentJdbcMethods(clazz, javax.sql.DataSource.class); + instrumentJdbcMethods(clazz, javax.sql.XADataSource.class); + clazz.writeFile(args[0]); + + /* + * javax.transaction.xa.Xid + */ + // com.mysql.cj.jdbc.MysqlXid implements Xid + clazz = pool.get(MysqlXid.class.getName()); + instrumentJdbcMethods(clazz, javax.transaction.xa.Xid.class); + clazz.writeFile(args[0]); + + /* + * TODO: + * java.sql.DataTruncation + */ + // com.mysql.cj.jdbc.exceptions.MysqlDataTruncation extends DataTruncation + + /* + * TODO: + * java.sql.SQLException + */ + // com.mysql.cj.jdbc.exceptions.NotUpdatable extends SQLException + // com.mysql.cj.jdbc.exceptions.OperationNotSupportedException extends SQLException + // com.mysql.cj.jdbc.exceptions.PacketTooBigException extends SQLException + + /* + * TODO: + * java.sql.SQLNonTransientException + */ + // com.mysql.cj.jdbc.exceptions.MySQLQueryInterruptedException extends SQLNonTransientException + // com.mysql.cj.jdbc.exceptions.MySQLStatementCancelledException extends SQLNonTransientException + + /* + * TODO: + * java.sql.SQLRecoverableException + */ + // com.mysql.cj.jdbc.exceptions.CommunicationsException extends SQLRecoverableException implements StreamingNotifiable + // ---> com.mysql.cj.jdbc.exceptions.ConnectionFeatureNotAvailableException extends CommunicationsException + + /* + * TODO: + * java.sql.SQLTransientException + * ---> java.sql.SQLTimeoutException + */ + // com.mysql.cj.jdbc.exceptions.MySQLTimeoutException extends SQLTimeoutException + + /* + * TODO: + * java.sql.SQLTransientException + * ---> java.sql.SQLTransactionRollbackException + */ + // com.mysql.cj.jdbc.exceptions.MySQLTransactionRollbackException extends SQLTransactionRollbackException implements DeadlockTimeoutRollbackMarker + + /* + * TODO: + * com.mysql.cj.jdbc.MysqlXAException extends javax.transaction.xa.XAException + */ + + /* + * These classes have no implementations in c/J: + * + * java.sql.Array + * java.sql.BatchUpdateException + * java.sql.ClientInfoStatus + * java.sql.Date + * java.sql.DriverManager + * java.sql.DriverPropertyInfo + * java.sql.PseudoColumnUsage + * java.sql.Ref + * java.sql.RowId + * java.sql.RowIdLifetime + * java.sql.SQLClientInfoException + * java.sql.SQLData + * java.sql.SQLDataException + * java.sql.SQLFeatureNotSupportedException + * java.sql.SQLInput + * java.sql.SQLIntegrityConstraintViolationException + * java.sql.SQLInvalidAuthorizationSpecException + * java.sql.SQLNonTransientConnectionException + * java.sql.SQLOutput + * java.sql.SQLPermission + * java.sql.SQLSyntaxErrorException + * java.sql.SQLTransientConnectionException + * java.sql.SQLWarning + * java.sql.Struct + * java.sql.Time + * java.sql.Timestamp + * java.sql.Types + * + * javax.sql.CommonDataSource + * javax.sql.ConnectionEvent + * javax.sql.ConnectionEventListener + * javax.sql.RowSet + * javax.sql.RowSetEvent + * javax.sql.RowSetInternal + * javax.sql.RowSetListener + * javax.sql.RowSetMetaData + * javax.sql.RowSetReader + * javax.sql.RowSetWriter + * javax.sql.StatementEvent + * javax.sql.StatementEventListener + * + * javax.sql.rowset.BaseRowSet + * javax.sql.rowset.CachedRowSet + * javax.sql.rowset.FilteredRowSet + * javax.sql.rowset.JdbcRowSet + * javax.sql.rowset.Joinable + * javax.sql.rowset.JoinRowSet + * javax.sql.rowset.Predicate + * javax.sql.rowset.RowSetFactory + * javax.sql.rowset.RowSetMetaDataImpl + * javax.sql.rowset.RowSetProvider + * javax.sql.rowset.RowSetWarning + * javax.sql.rowset.WebRowSet + * + * javax.sql.rowset.serial.SerialArray + * javax.sql.rowset.serial.SerialBlob + * javax.sql.rowset.serial.SerialClob + * javax.sql.rowset.serial.SerialDatalink + * javax.sql.rowset.serial.SerialException + * javax.sql.rowset.serial.SerialJavaObject + * javax.sql.rowset.serial.SerialRef + * javax.sql.rowset.serial.SerialStruct + * javax.sql.rowset.serial.SQLInputImpl + * javax.sql.rowset.serial.SQLOutputImpl + * + * javax.sql.rowset.spi.SyncFactory + * javax.sql.rowset.spi.SyncFactoryException + * javax.sql.rowset.spi.SyncProvider + * javax.sql.rowset.spi.SyncProviderException + * javax.sql.rowset.spi.SyncResolver + * javax.sql.rowset.spi.TransactionalWriter + * javax.sql.rowset.spi.XmlReader + * javax.sql.rowset.spi.XmlWriter + */ + } + + private static void instrumentJdbcMethods(CtClass cjClazz, Class jdbcClass) throws Exception { + instrumentJdbcMethods(cjClazz, jdbcClass, false, null); + } + + /** + * Instruments methods of cjClazz defined in jdbcClass. + * + * @param cjClazz + * CtClass to be instrumented. + * @param jdbcClass + * Class from JDBC specification where methods descriptors to be get. + * @param declaredMethodsOnly + * true - instrument methods declared in this class, false - also instrument inherited methods + * @param exceptionInterceptorStr + * exception interceptor reference as a string + * @throws Exception + * if an error occurs + */ + private static void instrumentJdbcMethods(CtClass cjClazz, Class jdbcClass, boolean declaredMethodsOnly, String exceptionInterceptorStr) + throws Exception { + sysOutPrintln("---"); + sysOutPrintln(cjClazz.getName()); + + Method[] methods; + if (declaredMethodsOnly) { + // instrument methods declared in this class which throws SQLException + methods = jdbcClass.getDeclaredMethods(); + } else { + // instrument all methods, declared in this class and it's superclasses, which throws SQLException + methods = jdbcClass.getMethods(); + } + + for (Method method : methods) { + CtMethod ctm = null; + String prefix = "SKIPPED: "; + for (Class exc : method.getExceptionTypes()) { + if (exc.equals(SQLException.class)) { + prefix = "INSTRUMENTING... "; + String jdbcClassName = method.getName(); + List params = new LinkedList<>(); + for (Class param : method.getParameterTypes()) { + params.add(pool.get(param.getName())); + } + try { + ctm = cjClazz.getDeclaredMethod(jdbcClassName, params.toArray(new CtClass[0])); + } catch (NotFoundException ex) { + // Just ignoring because the only reason is that the method is implemented in superclass + prefix = "NOT FOUND: "; + } + break; + } + } + sysOutPrint(prefix); + sysOutPrint(method.toGenericString()); + if (ctm != null) { + if (catchRuntimeException(cjClazz, ctm, exceptionInterceptorStr, false)) { + sysOutPrint(" ... DONE."); + } else { + sysOutPrint(" ... ALREADY PROCESSED!!!"); + } + } + sysOutPrintln(""); + } + + } + + private static void catchRuntimeException(CtClass clazz, CtMethod m, String exceptionInterceptorStr) throws Exception { + catchRuntimeException(clazz, m, exceptionInterceptorStr, true); + } + + private static boolean catchRuntimeException(CtClass clazz, CtMethod m, String exceptionInterceptorStr, boolean log) throws Exception { + if (isProcessed(clazz.getClassFile().getName(), m)) { + if (log) { + sysOutPrintln("ALREADY PROCESSED!!! " + m); + } + return false; + } + if (log) { + sysOutPrintln(m + ", " + exceptionInterceptorStr); + } + if (exceptionInterceptorStr == null) { + m.addCatch("{throw " + SQLExceptionsMapping.class.getName() + ".translateException(ex);}", runTimeException, "ex"); + } else { + m.addCatch("{throw " + SQLExceptionsMapping.class.getName() + ".translateException(ex, " + exceptionInterceptorStr + ");}", runTimeException, "ex"); + } + processed.get(clazz.getClassFile().getName()).add(m); + return true; + } + + private static boolean isProcessed(String fileName, CtMethod m) throws Exception { + List methods = processed.get(fileName); + if (methods != null) { + if (methods.contains(m)) { + return true; + } + } else { + processed.put(fileName, new LinkedList()); + } + return false; + } + + private static void sysOutPrint(String s) { + if (verbose) { + System.out.print(s); + } + } + + private static void sysOutPrintln(String s) { + if (verbose) { + System.out.println(s); + } + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/.project b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/.project new file mode 100644 index 0000000..3002ba4 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/.project @@ -0,0 +1,17 @@ + + + misc + + + + + + org.eclipse.m2e.core.maven2Builder + + + + + + org.eclipse.m2e.core.maven2Nature + + diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/Product.wxs b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/Product.wxs new file mode 100644 index 0000000..f4ac98c --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/Product.wxs @@ -0,0 +1,66 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/changelog b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/changelog new file mode 100644 index 0000000..97176b8 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/changelog @@ -0,0 +1,5 @@ +@PRODUCT_NAME@@PRODUCT_SUFFIX@ (@MYSQL_CJ_VERSION@@MYSQL_CJ_VERSION_SNAPSHOT@@DEB_VERSION_SUFFIX@@ID_RELEASE@) @CODENAME@; urgency=low + + * For release notes, please refer to https://dev.mysql.com/doc/relnotes/connector-j/8.0/en/ + + -- @MAINTAINER_EMAIL@ @PACKAGE_TIMESTAMP@ diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/compat b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/compat new file mode 100644 index 0000000..ec63514 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/compat @@ -0,0 +1 @@ +9 diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/control b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/control new file mode 100644 index 0000000..31a3f18 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/control @@ -0,0 +1,14 @@ +Source: @PRODUCT_NAME@@PRODUCT_SUFFIX@ +Section: database +Priority: optional +Maintainer: Oracle MySQL Product Engineering Team +Standards-Version: 3.9.2 +Build-Depends: debhelper (>= 8.9.4) +Homepage: http://dev.mysql.com/downloads/connector/j/ + +Package: @PRODUCT_NAME@@PRODUCT_SUFFIX@ +Section: database +Architecture: all +Depends: ${shlibs:Depends}, ${misc:Depends} +Description: MySQL Connector/J + Standardized MySQL database driver for Java diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/copyright b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/copyright new file mode 100644 index 0000000..75df281 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/copyright @@ -0,0 +1,9 @@ +Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ +Upstream-Name: @PRODUCT@ +Upstream-Contact: MySQL Release Engineering +Source: http://dev.mysql.com/ + +Files: * +Copyright: 2002, 2021, Oracle and/or its affiliates. +License: + For licensing information see the LICENSE file in this distribution. diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/install b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/install new file mode 100644 index 0000000..977c8a5 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/install @@ -0,0 +1,8 @@ +dist/toArchive/@PACKAGE_NAME@/@PRODUCT_NAME@@PRODUCT_SUFFIX@-@VERSION_FULL@.jar usr/share/java + +#legal +dist/toArchive/@PACKAGE_NAME@/@LIC_FILE@ usr/share/doc/@PRODUCT_NAME@@PRODUCT_SUFFIX@ +dist/toArchive/@PACKAGE_NAME@/README usr/share/doc/@PRODUCT_NAME@@PRODUCT_SUFFIX@ +dist/toArchive/@PACKAGE_NAME@/CHANGES usr/share/doc/@PRODUCT_NAME@@PRODUCT_SUFFIX@ +dist/toArchive/@PACKAGE_NAME@/INFO_SRC usr/share/doc/@PRODUCT_NAME@@PRODUCT_SUFFIX@ +dist/toArchive/@PACKAGE_NAME@/INFO_BIN usr/share/doc/@PRODUCT_NAME@@PRODUCT_SUFFIX@ diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/rules b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/rules new file mode 100644 index 0000000..28d7d4e --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/rules @@ -0,0 +1,77 @@ +#!/usr/bin/make -f +# Copyright (c) 2016, 2020, Oracle and/or its affiliates. +# +# This program is free software; you can redistribute it and/or modify it under +# the terms of the GNU General Public License, version 2.0, as published by the +# Free Software Foundation. +# +# This program is also distributed with certain software (including but not +# limited to OpenSSL) that is licensed under separate terms, as designated in a +# particular file or component or in included license documentation. The +# authors of MySQL hereby grant you an additional permission to link the +# program and your derivative works with the separately licensed software that +# they have included with MySQL. +# +# Without limiting anything contained in the foregoing, this file, which is +# part of MySQL Connector/J, is also subject to the Universal FOSS Exception, +# version 1.0, a copy of which can be found at +# http://oss.oracle.com/licenses/universal-foss-exception. +# +# This program is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +# FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, +# for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +upstream_version := $(shell dpkg-parsechangelog | sed -n -e'/^Version: / { s/Version: //; s/-[^-]\+$$//; p }') +base_version = $(shell echo $(upstream_version) | sed -e's/r[0-9]\+$$//') + +ANT_COMMON_OPTIONS=\ + -Dcom.mysql.cj.build.dir.driver=build/driver \ + -Dcom.mysql.cj.extra.libs=@WITH_JARDEPS@ \ + -Dcom.mysql.cj.build.driver.version.status=@MYSQL_CJ_VERSION_STATUS@ \ + -Dcom.mysql.cj.build.driver.version.extra=@MYSQL_CJ_VERSION_EXTRA@ \ + -Dcom.mysql.cj.build.driver.version.snapshot=@MYSQL_CJ_VERSION_SNAPSHOT@ \ + -Dcom.mysql.cj.build.driver.extraName=@PRODUCT_SUFFIX@ \ + -Dcom.mysql.cj.dist.licenseUrl=@MYSQL_CJ_LICENSEURL@ \ + -Djava.awt.headless=true + +ifeq ($(ANT_HOME),) +ANT_CMD=ant +else +ANT_CMD=$(ANT_HOME)/bin/ant +endif + +ANT_OPTS=-Xmx512M + +ifneq ($(JAVA_HOME),) +ANT_JAVA_OPT=-Dcom.mysql.cj.build.jdk=$(JAVA_HOME) +endif + +ifneq ($(COMMERCIAL),) +ANT_COM_OPT=-Dcom.mysql.cj.build.commercial=true +endif + +%: + #dh $@ --with autoreconf + dh $@ + +override_dh_auto_configure: + +override_dh_auto_build: + echo $(PATH) + echo $(JAVA_HOME) + $(ANT_CMD) \ + $(ANT_COMMON_OPTIONS) \ + $(ANT_JAVA_OPT) \ + $(ANT_COM_OPT) \ + full-package-no-sources + +override_dh_auto_clean: + $(ANT_CMD) $(ANT_COMMON_OPTIONS) clean + +override_dh_installchangelogs: + dh_installchangelogs -XCHANGES diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/source/format b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/source/format new file mode 100644 index 0000000..163aaf8 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/source/format @@ -0,0 +1 @@ +3.0 (quilt) diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/watch b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/watch new file mode 100644 index 0000000..ee25517 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/debian.in/watch @@ -0,0 +1,2 @@ +version=3 +http://mysql.osuosl.org/Downloads/@PRODUCT_NAME@-(.+)\.tar\.gz diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/pom.xml b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/pom.xml new file mode 100644 index 0000000..0b8b2cf --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/pom.xml @@ -0,0 +1,67 @@ + + + + 4.0.0 + mysql + mysql-connector-java + @MYSQL_CJ_VERSION@ + jar + + MySQL Connector/J + JDBC Type 4 driver for MySQL + + + + The GNU General Public License, v2 with FOSS exception + repo + For detailed license information see the LICENSE file in this distribution. + + + + http://dev.mysql.com/doc/connector-j/en/ + + + scm:git:git@github.com:mysql/mysql-connector-j.git + https://github.com/mysql/mysql-connector-j + + + + Oracle Corporation + http://www.oracle.com + + + + + com.google.protobuf + protobuf-java + 3.11.4 + + + diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/rpm.spec.in b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/rpm.spec.in new file mode 100644 index 0000000..d2926bb --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/build/misc/rpm.spec.in @@ -0,0 +1,197 @@ +# Copyright (c) 2017, 2020, Oracle and/or its affiliates. +# +# This program is free software; you can redistribute it and/or modify it under +# the terms of the GNU General Public License, version 2.0, as published by the +# Free Software Foundation. +# +# This program is also distributed with certain software (including but not +# limited to OpenSSL) that is licensed under separate terms, as designated in a +# particular file or component or in included license documentation. The +# authors of MySQL hereby grant you an additional permission to link the +# program and your derivative works with the separately licensed software that +# they have included with MySQL. +# +# Without limiting anything contained in the foregoing, this file, which is +# part of MySQL Connector/J, is also subject to the Universal FOSS Exception, +# version 1.0, a copy of which can be found at +# http://oss.oracle.com/licenses/universal-foss-exception. +# +# This program is distributed in the hope that it will be useful, but WITHOUT +# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS +# FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, +# for more details. +# +# You should have received a copy of the GNU General Public License along with +# this program; if not, write to the Free Software Foundation, Inc., +# 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + +# You can pass these options to "rpmbuild" +# +# --define="commercial " +# --define="with_ant " +# --define="with_java " +# --define="with_jardeps " +# --define="with_docs " +# +# The 'with_docs' option should have a path that points out +# +# /en/html/connector-j.html +# /en/html/mvl.css (not really used) +# /en/pdf/connector-j.pdf +# /en/txt/connector-j.txt + +# Some linux distributions doesn't set the "dist" macro. There is a +# list how to identify dists here +# https://en.opensuse.org/openSUSE:Build_Service_cross_distribution_howto + +# SuSE will not set "dist", others do +%if 0%{?suse_version} == 1315 +%global dist .sles12 +%global sles12 1 +%endif + +%if 0%{?suse_version} == 1500 +%global dist .sl15 +%global sles15 1 +%endif + +%if 0%{?commercial:1} +%global lic_tag Commercial +%else +%global lic_tag GPLv2 +%endif + +Summary: Standardized MySQL database driver for Java +Name: @MYSQL_CJ_EXTENDED_PROD_NAME@ +Version: @MYSQL_CJ_VERSION_NUMERIC@ +Release: @MYSQL_CJ_RPM_RELEASE_FULL@%{?dist} +Epoch: 1 +License: %{lic_tag} +Group: Development/Libraries +URL: http://dev.mysql.com/downloads/connector/j/ +Source0: https://cdn.mysql.com/Downloads/Connector-J/@MYSQL_CJ_FULL_PROD_NAME@.tar.gz + +BuildRoot: %{_tmppath}/%{name}-%{version}-build +BuildArch: noarch + +%if 0%{?commercial:1} +Obsoletes: mysql-connector-java < %{version}-%{release} +Provides: mysql-connector-java = %{version}-%{release} +%endif + +%if 0%{!?with_ant:1} +BuildRequires: ant +%endif + +%if 0%{!?with_java:1} +BuildRequires: java-devel >= 1:1.8.0 +%endif + +%if 0%{?sles12:1} || 0%{?sles15:1} +Requires: java-headless >= 1.8.0 +%else +Requires: java-headless >= 1:1.8.0 +%endif + +%description +MySQL provides connectivity for client applications developed in the +Java programming language with @MYSQL_CJ_DISPLAY_PROD_NAME@, a driver that +implements the [Java Database Connectivity (JDBC) API] +(http://www.oracle.com/technetwork/java/javase/jdbc/). + +@MYSQL_CJ_DISPLAY_PROD_NAME@ @MYSQL_CJ_VERSION_SERIES@ is a JDBC Type 4 driver that is compatible with +the [JDBC 4.2](http://docs.oracle.com/javase/8/docs/technotes/guides/jdbc/) +specification. The Type 4 designation means that the driver is a pure +Java implementation of the MySQL protocol and does not rely on the +MySQL client libraries. + +For detailed information please visit the official +[@MYSQL_CJ_DISPLAY_PROD_NAME@ documentation] +(http://dev.mysql.com/doc/connector-j/en/). + +%prep +%setup -q -n @MYSQL_CJ_FULL_PROD_NAME@ + +%build +COMMON_OPTIONS="\ + -Dcom.mysql.cj.build.dir.driver=build/driver + -Dcom.mysql.cj.extra.libs=%{with_jardeps} \ + -Dcom.mysql.cj.build.driver.version.status=@MYSQL_CJ_VERSION_STATUS@ \ + -Dcom.mysql.cj.build.driver.version.extra=@MYSQL_CJ_VERSION_EXTRA@ \ + -Dcom.mysql.cj.build.driver.version.snapshot=@MYSQL_CJ_VERSION_SNAPSHOT@ \ + -Dcom.mysql.cj.build.driver.extraName=@MYSQL_CJ_EXTRA_NAME@ \ + -Dcom.mysql.cj.dist.licenseUrl=@MYSQL_CJ_LICENSEURL@ \ + -Djava.awt.headless=true" + +%if 0%{?with_ant:1} +export ANT_HOME=%{with_ant} +export ANT_CMD="${ANT_HOME}/bin/ant" +%else +export ANT_CMD="ant" +%endif + +export ANT_OPTS=-Xmx512M + +%if 0%{?with_java:1} +export JAVA_HOME=%{with_java} +export PATH=${JAVA_HOME}/bin:$PATH +COMMON_OPTIONS="${COMMON_OPTIONS} -Dcom.mysql.cj.build.jdk=${JAVA_HOME}" +%endif + +%if 0%{?commercial:1} +COMMON_OPTIONS="${COMMON_OPTIONS} -Dcom.mysql.cj.build.commercial=true" +%endif + +# Get the file revision-info.properties again because it was excluded +# from SOURCES +cp %{_tmppath}/@MYSQL_CJ_FULL_PROD_NAME@/revision-info.properties . + +${ANT_CMD} \ + ${COMMON_OPTIONS} \ + full-package-no-sources + +# We use the 'full-package-no-sources' as there are changes done only +# when creating a package, 'dist' is not enough. To make it a bit easier +# in the install step, we rename the directory with the content +mv dist/toArchive/@PACKAGE_NAME@ package-content + +# The 'package' target doesn't copy the HTML or PDF doc like 'dist', +# we copy it here +%if 0%{?with_docs:1} +mkdir -p package-content/docs +cp %{with_docs}/en/html/connector-j.html package-content/docs/ +cp %{with_docs}/en/html/mvl.css package-content/docs/ +cp %{with_docs}/en/pdf/connector-j.pdf package-content/docs/ +cp %{with_docs}/en/txt/connector-j.txt package-content/docs/ +%endif + +%install +install -d -m 0755 %{buildroot}%{_javadir} +install -p -m 0644 package-content/@MYSQL_CJ_FULL_PROD_NAME@.jar %{buildroot}%{_javadir}/%{name}.jar + +%clean +rm -rf %{buildroot} + +%files +%doc package-content/CHANGES +# EL6 doesn't like 'license' macro here, so we use 'doc' +%doc package-content/LICENSE +%doc package-content/README +%doc package-content/INFO_BIN +%doc package-content/INFO_SRC + +%if 0%{?with_docs:1} +# README.txt is a rename of "connector-j.txt" +%doc package-content/docs/connector-j.txt +%doc package-content/docs/connector-j.pdf +%doc package-content/docs/connector-j.html +%doc package-content/docs/mvl.css +%endif + +%{_javadir}/%{name}.jar + +%changelog +* Mon Nov 27 2017 MySQL Release Engineering - 8.0.9-1 +- Set more in "build.xml" +* Tue Mar 14 2017 MySQL Release Engineering - 6.0.7-1 +- initial package diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/demo/java/demo/x/devapi/DevApiSample.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/demo/java/demo/x/devapi/DevApiSample.java new file mode 100644 index 0000000..4ef89e7 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/demo/java/demo/x/devapi/DevApiSample.java @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package demo.x.devapi; + +import com.mysql.cj.xdevapi.Collection; +import com.mysql.cj.xdevapi.DbDoc; +import com.mysql.cj.xdevapi.DbDocImpl; +import com.mysql.cj.xdevapi.DocResult; +import com.mysql.cj.xdevapi.JsonNumber; +import com.mysql.cj.xdevapi.JsonString; +import com.mysql.cj.xdevapi.Schema; +import com.mysql.cj.xdevapi.Session; +import com.mysql.cj.xdevapi.SessionFactory; + +/* + * Sample program showing how to use Connector/J's Dev API support. + */ +public class DevApiSample { + public static void main(String[] args) { + Session session = new SessionFactory().getSession("mysqlx://localhost:33060/test?user=user&password=password1234"); + System.err.println("Connected!"); + Schema schema = session.getDefaultSchema(); + System.err.println("Default schema is: " + schema); + + documentWalkthrough(schema); + } + + public static void documentWalkthrough(Schema schema) { + // document walthrough + Collection coll = schema.createCollection("myBooks", /* reuseExisting? */ true); + DbDoc newDoc = new DbDocImpl().add("isbn", new JsonString().setValue("12345")); + newDoc.add("title", new JsonString().setValue("Effi Briest")); + newDoc.add("author", new JsonString().setValue("Theodor Fontane")); + newDoc.add("currentlyReadingPage", new JsonNumber().setValue(String.valueOf(42))); + coll.add(newDoc).execute(); + + // note: "$" prefix for document paths is optional. "$.title.somethingElse[0]" is the same as "title.somethingElse[0]" in document expressions + DocResult docs = coll.find("$.title = 'Effi Briest' and $.currentlyReadingPage > 10").execute(); + DbDoc book = docs.next(); + System.err.println("Currently reading " + ((JsonString) book.get("title")).getString() + " on page " + + ((JsonNumber) book.get("currentlyReadingPage")).getInteger()); + + // increment the page number and fetch it again + coll.modify("$.isbn = 12345").set("$.currentlyReadingPage", ((JsonNumber) book.get("currentlyReadingPage")).getInteger() + 1).execute(); + + docs = coll.find("$.title = 'Effi Briest' and $.currentlyReadingPage > 10").execute(); + book = docs.next(); + System.err.println("Currently reading " + ((JsonString) book.get("title")).getString() + " on page " + + ((JsonNumber) book.get("currentlyReadingPage")).getInteger()); + + // remove the doc + coll.remove("true").execute(); + System.err.println("Number of books in collection: " + coll.count()); + + schema.dropCollection(coll.getName()); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/Mysqlx.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/Mysqlx.java new file mode 100644 index 0000000..0dd44d0 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/Mysqlx.java @@ -0,0 +1,3417 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.x.protobuf; + +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: mysqlx.proto + +public final class Mysqlx { + private Mysqlx() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + registry.add(com.mysql.cj.x.protobuf.Mysqlx.clientMessageId); + registry.add(com.mysql.cj.x.protobuf.Mysqlx.serverMessageId); + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + public interface ClientMessagesOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.ClientMessages) + com.google.protobuf.MessageOrBuilder { + } + /** + * 
+   **
+   *IDs of messages that can be sent from client to the server.
+   *@note
+   *This message is never sent on the wire. It is only used to let ``protoc``:
+   *-  generate constants
+   *-  check for uniqueness
+   *
+ * + * Protobuf type {@code Mysqlx.ClientMessages} + */ + public static final class ClientMessages extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.ClientMessages) + ClientMessagesOrBuilder { + private static final long serialVersionUID = 0L; + // Use ClientMessages.newBuilder() to construct. + private ClientMessages(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private ClientMessages() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new ClientMessages(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private ClientMessages( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.Mysqlx.internal_static_Mysqlx_ClientMessages_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.Mysqlx.internal_static_Mysqlx_ClientMessages_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.class, com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.Builder.class); + } + + /** + * Protobuf enum {@code Mysqlx.ClientMessages.Type} + */ + public enum Type + implements com.google.protobuf.ProtocolMessageEnum { + /** + * CON_CAPABILITIES_GET = 1; + */ + CON_CAPABILITIES_GET(1), + /** + * CON_CAPABILITIES_SET = 2; + */ + CON_CAPABILITIES_SET(2), + /** + * CON_CLOSE = 3; + */ + CON_CLOSE(3), + /** + * SESS_AUTHENTICATE_START = 4; + */ + SESS_AUTHENTICATE_START(4), + /** + * SESS_AUTHENTICATE_CONTINUE = 5; + */ + SESS_AUTHENTICATE_CONTINUE(5), + /** + * SESS_RESET = 6; + */ + SESS_RESET(6), + /** + * SESS_CLOSE = 7; + */ + SESS_CLOSE(7), + /** + * SQL_STMT_EXECUTE = 12; + */ + SQL_STMT_EXECUTE(12), + /** + * CRUD_FIND = 17; + */ + CRUD_FIND(17), + /** + * CRUD_INSERT = 18; + */ + CRUD_INSERT(18), + /** + * CRUD_UPDATE = 19; + */ + CRUD_UPDATE(19), + /** + * CRUD_DELETE = 20; + */ + CRUD_DELETE(20), + /** + * EXPECT_OPEN = 24; + */ + EXPECT_OPEN(24), + /** + * EXPECT_CLOSE = 25; + */ + EXPECT_CLOSE(25), + /** + * CRUD_CREATE_VIEW = 30; + */ + CRUD_CREATE_VIEW(30), + /** + * CRUD_MODIFY_VIEW = 31; + */ + CRUD_MODIFY_VIEW(31), + /** + * CRUD_DROP_VIEW = 32; + */ + CRUD_DROP_VIEW(32), + /** + * PREPARE_PREPARE = 40; + */ + PREPARE_PREPARE(40), + /** + * PREPARE_EXECUTE = 41; + */ + PREPARE_EXECUTE(41), + /** + * PREPARE_DEALLOCATE = 42; + */ + PREPARE_DEALLOCATE(42), + /** + * CURSOR_OPEN = 43; + */ + CURSOR_OPEN(43), + /** + * CURSOR_CLOSE = 44; + */ + CURSOR_CLOSE(44), + /** + * CURSOR_FETCH = 45; + */ + CURSOR_FETCH(45), + /** + * COMPRESSION = 46; + */ + COMPRESSION(46), + ; + + /** + * CON_CAPABILITIES_GET = 1; + */ + public static final int CON_CAPABILITIES_GET_VALUE = 1; + /** + * CON_CAPABILITIES_SET = 2; + */ + public static final int CON_CAPABILITIES_SET_VALUE = 2; + /** + * CON_CLOSE = 3; + */ + public static final int CON_CLOSE_VALUE = 3; + /** + * SESS_AUTHENTICATE_START = 4; + */ + public static final int SESS_AUTHENTICATE_START_VALUE = 4; + /** + * SESS_AUTHENTICATE_CONTINUE = 5; + */ + public static final int SESS_AUTHENTICATE_CONTINUE_VALUE = 5; + /** + * SESS_RESET = 6; + */ + public static final int SESS_RESET_VALUE = 6; + /** + * SESS_CLOSE = 7; + */ + public static final int SESS_CLOSE_VALUE = 7; + /** + * SQL_STMT_EXECUTE = 12; + */ + public static final int SQL_STMT_EXECUTE_VALUE = 12; + /** + * CRUD_FIND = 17; + */ + public static final int CRUD_FIND_VALUE = 17; + /** + * CRUD_INSERT = 18; + */ + public static final int CRUD_INSERT_VALUE = 18; + /** + * CRUD_UPDATE = 19; + */ + public static final int CRUD_UPDATE_VALUE = 19; + /** + * CRUD_DELETE = 20; + */ + public static final int CRUD_DELETE_VALUE = 20; + /** + * EXPECT_OPEN = 24; + */ + public static final int EXPECT_OPEN_VALUE = 24; + /** + * EXPECT_CLOSE = 25; + */ + public static final int EXPECT_CLOSE_VALUE = 25; + /** + * CRUD_CREATE_VIEW = 30; + */ + public static final int CRUD_CREATE_VIEW_VALUE = 30; + /** + * CRUD_MODIFY_VIEW = 31; + */ + public static final int CRUD_MODIFY_VIEW_VALUE = 31; + /** + * CRUD_DROP_VIEW = 32; + */ + public static final int CRUD_DROP_VIEW_VALUE = 32; + /** + * PREPARE_PREPARE = 40; + */ + public static final int PREPARE_PREPARE_VALUE = 40; + /** + * PREPARE_EXECUTE = 41; + */ + public static final int PREPARE_EXECUTE_VALUE = 41; + /** + * PREPARE_DEALLOCATE = 42; + */ + public static final int PREPARE_DEALLOCATE_VALUE = 42; + /** + * CURSOR_OPEN = 43; + */ + public static final int CURSOR_OPEN_VALUE = 43; + /** + * CURSOR_CLOSE = 44; + */ + public static final int CURSOR_CLOSE_VALUE = 44; + /** + * CURSOR_FETCH = 45; + */ + public static final int CURSOR_FETCH_VALUE = 45; + /** + * COMPRESSION = 46; + */ + public static final int COMPRESSION_VALUE = 46; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static Type valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static Type forNumber(int value) { + switch (value) { + case 1: return CON_CAPABILITIES_GET; + case 2: return CON_CAPABILITIES_SET; + case 3: return CON_CLOSE; + case 4: return SESS_AUTHENTICATE_START; + case 5: return SESS_AUTHENTICATE_CONTINUE; + case 6: return SESS_RESET; + case 7: return SESS_CLOSE; + case 12: return SQL_STMT_EXECUTE; + case 17: return CRUD_FIND; + case 18: return CRUD_INSERT; + case 19: return CRUD_UPDATE; + case 20: return CRUD_DELETE; + case 24: return EXPECT_OPEN; + case 25: return EXPECT_CLOSE; + case 30: return CRUD_CREATE_VIEW; + case 31: return CRUD_MODIFY_VIEW; + case 32: return CRUD_DROP_VIEW; + case 40: return PREPARE_PREPARE; + case 41: return PREPARE_EXECUTE; + case 42: return PREPARE_DEALLOCATE; + case 43: return CURSOR_OPEN; + case 44: return CURSOR_CLOSE; + case 45: return CURSOR_FETCH; + case 46: return COMPRESSION; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + Type> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Type findValueByNumber(int number) { + return Type.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.getDescriptor().getEnumTypes().get(0); + } + + private static final Type[] VALUES = values(); + + public static Type valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private Type(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.ClientMessages.Type) + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.Mysqlx.ClientMessages)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.Mysqlx.ClientMessages other = (com.mysql.cj.x.protobuf.Mysqlx.ClientMessages) obj; + + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.Mysqlx.ClientMessages parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ClientMessages parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ClientMessages parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ClientMessages parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ClientMessages parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ClientMessages parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ClientMessages parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ClientMessages parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ClientMessages parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ClientMessages parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ClientMessages parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ClientMessages parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.Mysqlx.ClientMessages prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *IDs of messages that can be sent from client to the server.
+     *@note
+     *This message is never sent on the wire. It is only used to let ``protoc``:
+     *-  generate constants
+     *-  check for uniqueness
+     *
+ * + * Protobuf type {@code Mysqlx.ClientMessages} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.ClientMessages) + com.mysql.cj.x.protobuf.Mysqlx.ClientMessagesOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.Mysqlx.internal_static_Mysqlx_ClientMessages_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.Mysqlx.internal_static_Mysqlx_ClientMessages_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.class, com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.Mysqlx.internal_static_Mysqlx_ClientMessages_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.Mysqlx.ClientMessages getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.Mysqlx.ClientMessages build() { + com.mysql.cj.x.protobuf.Mysqlx.ClientMessages result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.Mysqlx.ClientMessages buildPartial() { + com.mysql.cj.x.protobuf.Mysqlx.ClientMessages result = new com.mysql.cj.x.protobuf.Mysqlx.ClientMessages(this); + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.Mysqlx.ClientMessages) { + return mergeFrom((com.mysql.cj.x.protobuf.Mysqlx.ClientMessages)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.Mysqlx.ClientMessages other) { + if (other == com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.getDefaultInstance()) return this; + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.Mysqlx.ClientMessages parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.Mysqlx.ClientMessages) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.ClientMessages) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.ClientMessages) + private static final com.mysql.cj.x.protobuf.Mysqlx.ClientMessages DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.Mysqlx.ClientMessages(); + } + + public static com.mysql.cj.x.protobuf.Mysqlx.ClientMessages getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public ClientMessages parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new ClientMessages(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.Mysqlx.ClientMessages getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ServerMessagesOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.ServerMessages) + com.google.protobuf.MessageOrBuilder { + } + /** + * 
+   **
+   *IDs of messages that can be sent from server to client.
+   *@note
+   *This message is never sent on the wire. It is only used to let ``protoc``:
+   *-  generate constants
+   *-  check for uniqueness
+   *
+ * + * Protobuf type {@code Mysqlx.ServerMessages} + */ + public static final class ServerMessages extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.ServerMessages) + ServerMessagesOrBuilder { + private static final long serialVersionUID = 0L; + // Use ServerMessages.newBuilder() to construct. + private ServerMessages(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private ServerMessages() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new ServerMessages(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private ServerMessages( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.Mysqlx.internal_static_Mysqlx_ServerMessages_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.Mysqlx.internal_static_Mysqlx_ServerMessages_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.class, com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.Builder.class); + } + + /** + * Protobuf enum {@code Mysqlx.ServerMessages.Type} + */ + public enum Type + implements com.google.protobuf.ProtocolMessageEnum { + /** + * OK = 0; + */ + OK(0), + /** + * ERROR = 1; + */ + ERROR(1), + /** + * CONN_CAPABILITIES = 2; + */ + CONN_CAPABILITIES(2), + /** + * SESS_AUTHENTICATE_CONTINUE = 3; + */ + SESS_AUTHENTICATE_CONTINUE(3), + /** + * SESS_AUTHENTICATE_OK = 4; + */ + SESS_AUTHENTICATE_OK(4), + /** + * 
+       * NOTICE has to stay at 11 forever
+       *
+ * + * NOTICE = 11; + */ + NOTICE(11), + /** + * RESULTSET_COLUMN_META_DATA = 12; + */ + RESULTSET_COLUMN_META_DATA(12), + /** + * RESULTSET_ROW = 13; + */ + RESULTSET_ROW(13), + /** + * RESULTSET_FETCH_DONE = 14; + */ + RESULTSET_FETCH_DONE(14), + /** + * RESULTSET_FETCH_SUSPENDED = 15; + */ + RESULTSET_FETCH_SUSPENDED(15), + /** + * RESULTSET_FETCH_DONE_MORE_RESULTSETS = 16; + */ + RESULTSET_FETCH_DONE_MORE_RESULTSETS(16), + /** + * SQL_STMT_EXECUTE_OK = 17; + */ + SQL_STMT_EXECUTE_OK(17), + /** + * RESULTSET_FETCH_DONE_MORE_OUT_PARAMS = 18; + */ + RESULTSET_FETCH_DONE_MORE_OUT_PARAMS(18), + /** + * COMPRESSION = 19; + */ + COMPRESSION(19), + ; + + /** + * OK = 0; + */ + public static final int OK_VALUE = 0; + /** + * ERROR = 1; + */ + public static final int ERROR_VALUE = 1; + /** + * CONN_CAPABILITIES = 2; + */ + public static final int CONN_CAPABILITIES_VALUE = 2; + /** + * SESS_AUTHENTICATE_CONTINUE = 3; + */ + public static final int SESS_AUTHENTICATE_CONTINUE_VALUE = 3; + /** + * SESS_AUTHENTICATE_OK = 4; + */ + public static final int SESS_AUTHENTICATE_OK_VALUE = 4; + /** + * 
+       * NOTICE has to stay at 11 forever
+       *
+ * + * NOTICE = 11; + */ + public static final int NOTICE_VALUE = 11; + /** + * RESULTSET_COLUMN_META_DATA = 12; + */ + public static final int RESULTSET_COLUMN_META_DATA_VALUE = 12; + /** + * RESULTSET_ROW = 13; + */ + public static final int RESULTSET_ROW_VALUE = 13; + /** + * RESULTSET_FETCH_DONE = 14; + */ + public static final int RESULTSET_FETCH_DONE_VALUE = 14; + /** + * RESULTSET_FETCH_SUSPENDED = 15; + */ + public static final int RESULTSET_FETCH_SUSPENDED_VALUE = 15; + /** + * RESULTSET_FETCH_DONE_MORE_RESULTSETS = 16; + */ + public static final int RESULTSET_FETCH_DONE_MORE_RESULTSETS_VALUE = 16; + /** + * SQL_STMT_EXECUTE_OK = 17; + */ + public static final int SQL_STMT_EXECUTE_OK_VALUE = 17; + /** + * RESULTSET_FETCH_DONE_MORE_OUT_PARAMS = 18; + */ + public static final int RESULTSET_FETCH_DONE_MORE_OUT_PARAMS_VALUE = 18; + /** + * COMPRESSION = 19; + */ + public static final int COMPRESSION_VALUE = 19; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static Type valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static Type forNumber(int value) { + switch (value) { + case 0: return OK; + case 1: return ERROR; + case 2: return CONN_CAPABILITIES; + case 3: return SESS_AUTHENTICATE_CONTINUE; + case 4: return SESS_AUTHENTICATE_OK; + case 11: return NOTICE; + case 12: return RESULTSET_COLUMN_META_DATA; + case 13: return RESULTSET_ROW; + case 14: return RESULTSET_FETCH_DONE; + case 15: return RESULTSET_FETCH_SUSPENDED; + case 16: return RESULTSET_FETCH_DONE_MORE_RESULTSETS; + case 17: return SQL_STMT_EXECUTE_OK; + case 18: return RESULTSET_FETCH_DONE_MORE_OUT_PARAMS; + case 19: return COMPRESSION; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + Type> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Type findValueByNumber(int number) { + return Type.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.getDescriptor().getEnumTypes().get(0); + } + + private static final Type[] VALUES = values(); + + public static Type valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private Type(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.ServerMessages.Type) + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.Mysqlx.ServerMessages)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.Mysqlx.ServerMessages other = (com.mysql.cj.x.protobuf.Mysqlx.ServerMessages) obj; + + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.Mysqlx.ServerMessages parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ServerMessages parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ServerMessages parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ServerMessages parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ServerMessages parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ServerMessages parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ServerMessages parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ServerMessages parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ServerMessages parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ServerMessages parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ServerMessages parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.Mysqlx.ServerMessages parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.Mysqlx.ServerMessages prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *IDs of messages that can be sent from server to client.
+     *@note
+     *This message is never sent on the wire. It is only used to let ``protoc``:
+     *-  generate constants
+     *-  check for uniqueness
+     *
+ * + * Protobuf type {@code Mysqlx.ServerMessages} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.ServerMessages) + com.mysql.cj.x.protobuf.Mysqlx.ServerMessagesOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.Mysqlx.internal_static_Mysqlx_ServerMessages_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.Mysqlx.internal_static_Mysqlx_ServerMessages_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.class, com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.Mysqlx.internal_static_Mysqlx_ServerMessages_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.Mysqlx.ServerMessages getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.Mysqlx.ServerMessages build() { + com.mysql.cj.x.protobuf.Mysqlx.ServerMessages result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.Mysqlx.ServerMessages buildPartial() { + com.mysql.cj.x.protobuf.Mysqlx.ServerMessages result = new com.mysql.cj.x.protobuf.Mysqlx.ServerMessages(this); + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.Mysqlx.ServerMessages) { + return mergeFrom((com.mysql.cj.x.protobuf.Mysqlx.ServerMessages)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.Mysqlx.ServerMessages other) { + if (other == com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.getDefaultInstance()) return this; + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.Mysqlx.ServerMessages parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.Mysqlx.ServerMessages) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.ServerMessages) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.ServerMessages) + private static final com.mysql.cj.x.protobuf.Mysqlx.ServerMessages DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.Mysqlx.ServerMessages(); + } + + public static com.mysql.cj.x.protobuf.Mysqlx.ServerMessages getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public ServerMessages parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new ServerMessages(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.Mysqlx.ServerMessages getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface OkOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Ok) + com.google.protobuf.MessageOrBuilder { + + /** + * optional string msg = 1; + * @return Whether the msg field is set. + */ + boolean hasMsg(); + /** + * optional string msg = 1; + * @return The msg. + */ + java.lang.String getMsg(); + /** + * optional string msg = 1; + * @return The bytes for msg. + */ + com.google.protobuf.ByteString + getMsgBytes(); + } + /** + * Protobuf type {@code Mysqlx.Ok} + */ + public static final class Ok extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Ok) + OkOrBuilder { + private static final long serialVersionUID = 0L; + // Use Ok.newBuilder() to construct. + private Ok(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Ok() { + msg_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Ok(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Ok( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000001; + msg_ = bs; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.Mysqlx.internal_static_Mysqlx_Ok_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.Mysqlx.internal_static_Mysqlx_Ok_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.Mysqlx.Ok.class, com.mysql.cj.x.protobuf.Mysqlx.Ok.Builder.class); + } + + private int bitField0_; + public static final int MSG_FIELD_NUMBER = 1; + private volatile java.lang.Object msg_; + /** + * optional string msg = 1; + * @return Whether the msg field is set. + */ + public boolean hasMsg() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * optional string msg = 1; + * @return The msg. + */ + public java.lang.String getMsg() { + java.lang.Object ref = msg_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + msg_ = s; + } + return s; + } + } + /** + * optional string msg = 1; + * @return The bytes for msg. + */ + public com.google.protobuf.ByteString + getMsgBytes() { + java.lang.Object ref = msg_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + msg_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, msg_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, msg_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.Mysqlx.Ok)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.Mysqlx.Ok other = (com.mysql.cj.x.protobuf.Mysqlx.Ok) obj; + + if (hasMsg() != other.hasMsg()) return false; + if (hasMsg()) { + if (!getMsg() + .equals(other.getMsg())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasMsg()) { + hash = (37 * hash) + MSG_FIELD_NUMBER; + hash = (53 * hash) + getMsg().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.Mysqlx.Ok parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Ok parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Ok parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Ok parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Ok parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Ok parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Ok parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Ok parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Ok parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Ok parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Ok parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Ok parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.Mysqlx.Ok prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Mysqlx.Ok} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Ok) + com.mysql.cj.x.protobuf.Mysqlx.OkOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.Mysqlx.internal_static_Mysqlx_Ok_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.Mysqlx.internal_static_Mysqlx_Ok_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.Mysqlx.Ok.class, com.mysql.cj.x.protobuf.Mysqlx.Ok.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.Mysqlx.Ok.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + msg_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.Mysqlx.internal_static_Mysqlx_Ok_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.Mysqlx.Ok getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.Mysqlx.Ok.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.Mysqlx.Ok build() { + com.mysql.cj.x.protobuf.Mysqlx.Ok result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.Mysqlx.Ok buildPartial() { + com.mysql.cj.x.protobuf.Mysqlx.Ok result = new com.mysql.cj.x.protobuf.Mysqlx.Ok(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.msg_ = msg_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.Mysqlx.Ok) { + return mergeFrom((com.mysql.cj.x.protobuf.Mysqlx.Ok)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.Mysqlx.Ok other) { + if (other == com.mysql.cj.x.protobuf.Mysqlx.Ok.getDefaultInstance()) return this; + if (other.hasMsg()) { + bitField0_ |= 0x00000001; + msg_ = other.msg_; + onChanged(); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.Mysqlx.Ok parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.Mysqlx.Ok) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object msg_ = ""; + /** + * optional string msg = 1; + * @return Whether the msg field is set. + */ + public boolean hasMsg() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * optional string msg = 1; + * @return The msg. + */ + public java.lang.String getMsg() { + java.lang.Object ref = msg_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + msg_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string msg = 1; + * @return The bytes for msg. + */ + public com.google.protobuf.ByteString + getMsgBytes() { + java.lang.Object ref = msg_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + msg_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * optional string msg = 1; + * @param value The msg to set. + * @return This builder for chaining. + */ + public Builder setMsg( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + msg_ = value; + onChanged(); + return this; + } + /** + * optional string msg = 1; + * @return This builder for chaining. + */ + public Builder clearMsg() { + bitField0_ = (bitField0_ & ~0x00000001); + msg_ = getDefaultInstance().getMsg(); + onChanged(); + return this; + } + /** + * optional string msg = 1; + * @param value The bytes for msg to set. + * @return This builder for chaining. + */ + public Builder setMsgBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + msg_ = value; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Ok) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Ok) + private static final com.mysql.cj.x.protobuf.Mysqlx.Ok DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.Mysqlx.Ok(); + } + + public static com.mysql.cj.x.protobuf.Mysqlx.Ok getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Ok parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Ok(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.Mysqlx.Ok getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ErrorOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Error) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** severity of the error message 
+     *
+ * + * optional .Mysqlx.Error.Severity severity = 1 [default = ERROR]; + * @return Whether the severity field is set. + */ + boolean hasSeverity(); + /** + * 
+     ** severity of the error message 
+     *
+ * + * optional .Mysqlx.Error.Severity severity = 1 [default = ERROR]; + * @return The severity. + */ + com.mysql.cj.x.protobuf.Mysqlx.Error.Severity getSeverity(); + + /** + * 
+     ** error-code 
+     *
+ * + * required uint32 code = 2; + * @return Whether the code field is set. + */ + boolean hasCode(); + /** + * 
+     ** error-code 
+     *
+ * + * required uint32 code = 2; + * @return The code. + */ + int getCode(); + + /** + * 
+     ** SQL state 
+     *
+ * + * required string sql_state = 4; + * @return Whether the sqlState field is set. + */ + boolean hasSqlState(); + /** + * 
+     ** SQL state 
+     *
+ * + * required string sql_state = 4; + * @return The sqlState. + */ + java.lang.String getSqlState(); + /** + * 
+     ** SQL state 
+     *
+ * + * required string sql_state = 4; + * @return The bytes for sqlState. + */ + com.google.protobuf.ByteString + getSqlStateBytes(); + + /** + * 
+     ** human readable error message 
+     *
+ * + * required string msg = 3; + * @return Whether the msg field is set. + */ + boolean hasMsg(); + /** + * 
+     ** human readable error message 
+     *
+ * + * required string msg = 3; + * @return The msg. + */ + java.lang.String getMsg(); + /** + * 
+     ** human readable error message 
+     *
+ * + * required string msg = 3; + * @return The bytes for msg. + */ + com.google.protobuf.ByteString + getMsgBytes(); + } + /** + * Protobuf type {@code Mysqlx.Error} + */ + public static final class Error extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Error) + ErrorOrBuilder { + private static final long serialVersionUID = 0L; + // Use Error.newBuilder() to construct. + private Error(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Error() { + severity_ = 0; + sqlState_ = ""; + msg_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Error(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Error( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.Mysqlx.Error.Severity value = com.mysql.cj.x.protobuf.Mysqlx.Error.Severity.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(1, rawValue); + } else { + bitField0_ |= 0x00000001; + severity_ = rawValue; + } + break; + } + case 16: { + bitField0_ |= 0x00000002; + code_ = input.readUInt32(); + break; + } + case 26: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000008; + msg_ = bs; + break; + } + case 34: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000004; + sqlState_ = bs; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.Mysqlx.internal_static_Mysqlx_Error_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.Mysqlx.internal_static_Mysqlx_Error_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.Mysqlx.Error.class, com.mysql.cj.x.protobuf.Mysqlx.Error.Builder.class); + } + + /** + * Protobuf enum {@code Mysqlx.Error.Severity} + */ + public enum Severity + implements com.google.protobuf.ProtocolMessageEnum { + /** + * ERROR = 0; + */ + ERROR(0), + /** + * FATAL = 1; + */ + FATAL(1), + ; + + /** + * ERROR = 0; + */ + public static final int ERROR_VALUE = 0; + /** + * FATAL = 1; + */ + public static final int FATAL_VALUE = 1; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static Severity valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static Severity forNumber(int value) { + switch (value) { + case 0: return ERROR; + case 1: return FATAL; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + Severity> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Severity findValueByNumber(int number) { + return Severity.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.Mysqlx.Error.getDescriptor().getEnumTypes().get(0); + } + + private static final Severity[] VALUES = values(); + + public static Severity valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private Severity(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Error.Severity) + } + + private int bitField0_; + public static final int SEVERITY_FIELD_NUMBER = 1; + private int severity_; + /** + * 
+     ** severity of the error message 
+     *
+ * + * optional .Mysqlx.Error.Severity severity = 1 [default = ERROR]; + * @return Whether the severity field is set. + */ + public boolean hasSeverity() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** severity of the error message 
+     *
+ * + * optional .Mysqlx.Error.Severity severity = 1 [default = ERROR]; + * @return The severity. + */ + public com.mysql.cj.x.protobuf.Mysqlx.Error.Severity getSeverity() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.Mysqlx.Error.Severity result = com.mysql.cj.x.protobuf.Mysqlx.Error.Severity.valueOf(severity_); + return result == null ? com.mysql.cj.x.protobuf.Mysqlx.Error.Severity.ERROR : result; + } + + public static final int CODE_FIELD_NUMBER = 2; + private int code_; + /** + * 
+     ** error-code 
+     *
+ * + * required uint32 code = 2; + * @return Whether the code field is set. + */ + public boolean hasCode() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** error-code 
+     *
+ * + * required uint32 code = 2; + * @return The code. + */ + public int getCode() { + return code_; + } + + public static final int SQL_STATE_FIELD_NUMBER = 4; + private volatile java.lang.Object sqlState_; + /** + * 
+     ** SQL state 
+     *
+ * + * required string sql_state = 4; + * @return Whether the sqlState field is set. + */ + public boolean hasSqlState() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+     ** SQL state 
+     *
+ * + * required string sql_state = 4; + * @return The sqlState. + */ + public java.lang.String getSqlState() { + java.lang.Object ref = sqlState_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + sqlState_ = s; + } + return s; + } + } + /** + * 
+     ** SQL state 
+     *
+ * + * required string sql_state = 4; + * @return The bytes for sqlState. + */ + public com.google.protobuf.ByteString + getSqlStateBytes() { + java.lang.Object ref = sqlState_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + sqlState_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int MSG_FIELD_NUMBER = 3; + private volatile java.lang.Object msg_; + /** + * 
+     ** human readable error message 
+     *
+ * + * required string msg = 3; + * @return Whether the msg field is set. + */ + public boolean hasMsg() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * 
+     ** human readable error message 
+     *
+ * + * required string msg = 3; + * @return The msg. + */ + public java.lang.String getMsg() { + java.lang.Object ref = msg_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + msg_ = s; + } + return s; + } + } + /** + * 
+     ** human readable error message 
+     *
+ * + * required string msg = 3; + * @return The bytes for msg. + */ + public com.google.protobuf.ByteString + getMsgBytes() { + java.lang.Object ref = msg_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + msg_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasCode()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasSqlState()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasMsg()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeEnum(1, severity_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeUInt32(2, code_); + } + if (((bitField0_ & 0x00000008) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 3, msg_); + } + if (((bitField0_ & 0x00000004) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 4, sqlState_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(1, severity_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(2, code_); + } + if (((bitField0_ & 0x00000008) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, msg_); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(4, sqlState_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.Mysqlx.Error)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.Mysqlx.Error other = (com.mysql.cj.x.protobuf.Mysqlx.Error) obj; + + if (hasSeverity() != other.hasSeverity()) return false; + if (hasSeverity()) { + if (severity_ != other.severity_) return false; + } + if (hasCode() != other.hasCode()) return false; + if (hasCode()) { + if (getCode() + != other.getCode()) return false; + } + if (hasSqlState() != other.hasSqlState()) return false; + if (hasSqlState()) { + if (!getSqlState() + .equals(other.getSqlState())) return false; + } + if (hasMsg() != other.hasMsg()) return false; + if (hasMsg()) { + if (!getMsg() + .equals(other.getMsg())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasSeverity()) { + hash = (37 * hash) + SEVERITY_FIELD_NUMBER; + hash = (53 * hash) + severity_; + } + if (hasCode()) { + hash = (37 * hash) + CODE_FIELD_NUMBER; + hash = (53 * hash) + getCode(); + } + if (hasSqlState()) { + hash = (37 * hash) + SQL_STATE_FIELD_NUMBER; + hash = (53 * hash) + getSqlState().hashCode(); + } + if (hasMsg()) { + hash = (37 * hash) + MSG_FIELD_NUMBER; + hash = (53 * hash) + getMsg().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.Mysqlx.Error parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Error parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Error parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Error parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Error parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Error parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Error parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Error parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Error parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Error parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Error parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.Mysqlx.Error parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.Mysqlx.Error prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Mysqlx.Error} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Error) + com.mysql.cj.x.protobuf.Mysqlx.ErrorOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.Mysqlx.internal_static_Mysqlx_Error_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.Mysqlx.internal_static_Mysqlx_Error_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.Mysqlx.Error.class, com.mysql.cj.x.protobuf.Mysqlx.Error.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.Mysqlx.Error.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + severity_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + code_ = 0; + bitField0_ = (bitField0_ & ~0x00000002); + sqlState_ = ""; + bitField0_ = (bitField0_ & ~0x00000004); + msg_ = ""; + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.Mysqlx.internal_static_Mysqlx_Error_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.Mysqlx.Error getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.Mysqlx.Error.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.Mysqlx.Error build() { + com.mysql.cj.x.protobuf.Mysqlx.Error result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.Mysqlx.Error buildPartial() { + com.mysql.cj.x.protobuf.Mysqlx.Error result = new com.mysql.cj.x.protobuf.Mysqlx.Error(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.severity_ = severity_; + if (((from_bitField0_ & 0x00000002) != 0)) { + result.code_ = code_; + to_bitField0_ |= 0x00000002; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + to_bitField0_ |= 0x00000004; + } + result.sqlState_ = sqlState_; + if (((from_bitField0_ & 0x00000008) != 0)) { + to_bitField0_ |= 0x00000008; + } + result.msg_ = msg_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.Mysqlx.Error) { + return mergeFrom((com.mysql.cj.x.protobuf.Mysqlx.Error)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.Mysqlx.Error other) { + if (other == com.mysql.cj.x.protobuf.Mysqlx.Error.getDefaultInstance()) return this; + if (other.hasSeverity()) { + setSeverity(other.getSeverity()); + } + if (other.hasCode()) { + setCode(other.getCode()); + } + if (other.hasSqlState()) { + bitField0_ |= 0x00000004; + sqlState_ = other.sqlState_; + onChanged(); + } + if (other.hasMsg()) { + bitField0_ |= 0x00000008; + msg_ = other.msg_; + onChanged(); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasCode()) { + return false; + } + if (!hasSqlState()) { + return false; + } + if (!hasMsg()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.Mysqlx.Error parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.Mysqlx.Error) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int severity_ = 0; + /** + * 
+       ** severity of the error message 
+       *
+ * + * optional .Mysqlx.Error.Severity severity = 1 [default = ERROR]; + * @return Whether the severity field is set. + */ + public boolean hasSeverity() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** severity of the error message 
+       *
+ * + * optional .Mysqlx.Error.Severity severity = 1 [default = ERROR]; + * @return The severity. + */ + public com.mysql.cj.x.protobuf.Mysqlx.Error.Severity getSeverity() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.Mysqlx.Error.Severity result = com.mysql.cj.x.protobuf.Mysqlx.Error.Severity.valueOf(severity_); + return result == null ? com.mysql.cj.x.protobuf.Mysqlx.Error.Severity.ERROR : result; + } + /** + * 
+       ** severity of the error message 
+       *
+ * + * optional .Mysqlx.Error.Severity severity = 1 [default = ERROR]; + * @param value The severity to set. + * @return This builder for chaining. + */ + public Builder setSeverity(com.mysql.cj.x.protobuf.Mysqlx.Error.Severity value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + severity_ = value.getNumber(); + onChanged(); + return this; + } + /** + * 
+       ** severity of the error message 
+       *
+ * + * optional .Mysqlx.Error.Severity severity = 1 [default = ERROR]; + * @return This builder for chaining. + */ + public Builder clearSeverity() { + bitField0_ = (bitField0_ & ~0x00000001); + severity_ = 0; + onChanged(); + return this; + } + + private int code_ ; + /** + * 
+       ** error-code 
+       *
+ * + * required uint32 code = 2; + * @return Whether the code field is set. + */ + public boolean hasCode() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** error-code 
+       *
+ * + * required uint32 code = 2; + * @return The code. + */ + public int getCode() { + return code_; + } + /** + * 
+       ** error-code 
+       *
+ * + * required uint32 code = 2; + * @param value The code to set. + * @return This builder for chaining. + */ + public Builder setCode(int value) { + bitField0_ |= 0x00000002; + code_ = value; + onChanged(); + return this; + } + /** + * 
+       ** error-code 
+       *
+ * + * required uint32 code = 2; + * @return This builder for chaining. + */ + public Builder clearCode() { + bitField0_ = (bitField0_ & ~0x00000002); + code_ = 0; + onChanged(); + return this; + } + + private java.lang.Object sqlState_ = ""; + /** + * 
+       ** SQL state 
+       *
+ * + * required string sql_state = 4; + * @return Whether the sqlState field is set. + */ + public boolean hasSqlState() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+       ** SQL state 
+       *
+ * + * required string sql_state = 4; + * @return The sqlState. + */ + public java.lang.String getSqlState() { + java.lang.Object ref = sqlState_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + sqlState_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * 
+       ** SQL state 
+       *
+ * + * required string sql_state = 4; + * @return The bytes for sqlState. + */ + public com.google.protobuf.ByteString + getSqlStateBytes() { + java.lang.Object ref = sqlState_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + sqlState_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * 
+       ** SQL state 
+       *
+ * + * required string sql_state = 4; + * @param value The sqlState to set. + * @return This builder for chaining. + */ + public Builder setSqlState( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + sqlState_ = value; + onChanged(); + return this; + } + /** + * 
+       ** SQL state 
+       *
+ * + * required string sql_state = 4; + * @return This builder for chaining. + */ + public Builder clearSqlState() { + bitField0_ = (bitField0_ & ~0x00000004); + sqlState_ = getDefaultInstance().getSqlState(); + onChanged(); + return this; + } + /** + * 
+       ** SQL state 
+       *
+ * + * required string sql_state = 4; + * @param value The bytes for sqlState to set. + * @return This builder for chaining. + */ + public Builder setSqlStateBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + sqlState_ = value; + onChanged(); + return this; + } + + private java.lang.Object msg_ = ""; + /** + * 
+       ** human readable error message 
+       *
+ * + * required string msg = 3; + * @return Whether the msg field is set. + */ + public boolean hasMsg() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * 
+       ** human readable error message 
+       *
+ * + * required string msg = 3; + * @return The msg. + */ + public java.lang.String getMsg() { + java.lang.Object ref = msg_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + msg_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * 
+       ** human readable error message 
+       *
+ * + * required string msg = 3; + * @return The bytes for msg. + */ + public com.google.protobuf.ByteString + getMsgBytes() { + java.lang.Object ref = msg_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + msg_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * 
+       ** human readable error message 
+       *
+ * + * required string msg = 3; + * @param value The msg to set. + * @return This builder for chaining. + */ + public Builder setMsg( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + msg_ = value; + onChanged(); + return this; + } + /** + * 
+       ** human readable error message 
+       *
+ * + * required string msg = 3; + * @return This builder for chaining. + */ + public Builder clearMsg() { + bitField0_ = (bitField0_ & ~0x00000008); + msg_ = getDefaultInstance().getMsg(); + onChanged(); + return this; + } + /** + * 
+       ** human readable error message 
+       *
+ * + * required string msg = 3; + * @param value The bytes for msg to set. + * @return This builder for chaining. + */ + public Builder setMsgBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + msg_ = value; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Error) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Error) + private static final com.mysql.cj.x.protobuf.Mysqlx.Error DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.Mysqlx.Error(); + } + + public static com.mysql.cj.x.protobuf.Mysqlx.Error getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Error parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Error(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.Mysqlx.Error getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public static final int CLIENT_MESSAGE_ID_FIELD_NUMBER = 100001; + /** + * extend .google.protobuf.MessageOptions { ... } + */ + public static final + com.google.protobuf.GeneratedMessage.GeneratedExtension< + com.google.protobuf.DescriptorProtos.MessageOptions, + com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.Type> clientMessageId = com.google.protobuf.GeneratedMessage + .newFileScopedGeneratedExtension( + com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.Type.class, + null); + public static final int SERVER_MESSAGE_ID_FIELD_NUMBER = 100002; + /** + * extend .google.protobuf.MessageOptions { ... } + */ + public static final + com.google.protobuf.GeneratedMessage.GeneratedExtension< + com.google.protobuf.DescriptorProtos.MessageOptions, + com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.Type> serverMessageId = com.google.protobuf.GeneratedMessage + .newFileScopedGeneratedExtension( + com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.Type.class, + null); + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_ClientMessages_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_ClientMessages_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_ServerMessages_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_ServerMessages_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Ok_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Ok_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Error_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Error_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\014mysqlx.proto\022\006Mysqlx\032 google/protobuf/" + + "descriptor.proto\"\374\003\n\016ClientMessages\"\351\003\n\004" + + "Type\022\030\n\024CON_CAPABILITIES_GET\020\001\022\030\n\024CON_CA" + + "PABILITIES_SET\020\002\022\r\n\tCON_CLOSE\020\003\022\033\n\027SESS_" + + "AUTHENTICATE_START\020\004\022\036\n\032SESS_AUTHENTICAT" + + "E_CONTINUE\020\005\022\016\n\nSESS_RESET\020\006\022\016\n\nSESS_CLO" + + "SE\020\007\022\024\n\020SQL_STMT_EXECUTE\020\014\022\r\n\tCRUD_FIND\020" + + "\021\022\017\n\013CRUD_INSERT\020\022\022\017\n\013CRUD_UPDATE\020\023\022\017\n\013C" + + "RUD_DELETE\020\024\022\017\n\013EXPECT_OPEN\020\030\022\020\n\014EXPECT_" + + "CLOSE\020\031\022\024\n\020CRUD_CREATE_VIEW\020\036\022\024\n\020CRUD_MO" + + "DIFY_VIEW\020\037\022\022\n\016CRUD_DROP_VIEW\020 \022\023\n\017PREPA" + + "RE_PREPARE\020(\022\023\n\017PREPARE_EXECUTE\020)\022\026\n\022PRE" + + "PARE_DEALLOCATE\020*\022\017\n\013CURSOR_OPEN\020+\022\020\n\014CU" + + "RSOR_CLOSE\020,\022\020\n\014CURSOR_FETCH\020-\022\017\n\013COMPRE" + + "SSION\020.\"\363\002\n\016ServerMessages\"\340\002\n\004Type\022\006\n\002O" + + "K\020\000\022\t\n\005ERROR\020\001\022\025\n\021CONN_CAPABILITIES\020\002\022\036\n" + + "\032SESS_AUTHENTICATE_CONTINUE\020\003\022\030\n\024SESS_AU" + + "THENTICATE_OK\020\004\022\n\n\006NOTICE\020\013\022\036\n\032RESULTSET" + + "_COLUMN_META_DATA\020\014\022\021\n\rRESULTSET_ROW\020\r\022\030" + + "\n\024RESULTSET_FETCH_DONE\020\016\022\035\n\031RESULTSET_FE" + + "TCH_SUSPENDED\020\017\022(\n$RESULTSET_FETCH_DONE_" + + "MORE_RESULTSETS\020\020\022\027\n\023SQL_STMT_EXECUTE_OK" + + "\020\021\022(\n$RESULTSET_FETCH_DONE_MORE_OUT_PARA" + + "MS\020\022\022\017\n\013COMPRESSION\020\023\"\027\n\002Ok\022\013\n\003msg\030\001 \001(\t" + + ":\004\220\3520\000\"\216\001\n\005Error\022/\n\010severity\030\001 \001(\0162\026.Mys" + + "qlx.Error.Severity:\005ERROR\022\014\n\004code\030\002 \002(\r\022" + + "\021\n\tsql_state\030\004 \002(\t\022\013\n\003msg\030\003 \002(\t\" \n\010Sever" + + "ity\022\t\n\005ERROR\020\000\022\t\n\005FATAL\020\001:\004\220\3520\001:Y\n\021clien" + + "t_message_id\022\037.google.protobuf.MessageOp" + + "tions\030\241\215\006 \001(\0162\033.Mysqlx.ClientMessages.Ty" + + "pe:Y\n\021server_message_id\022\037.google.protobu" + + "f.MessageOptions\030\242\215\006 \001(\0162\033.Mysqlx.Server" + + "Messages.TypeB\031\n\027com.mysql.cj.x.protobuf" + }; + descriptor = com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + com.google.protobuf.DescriptorProtos.getDescriptor(), + }); + internal_static_Mysqlx_ClientMessages_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_Mysqlx_ClientMessages_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_ClientMessages_descriptor, + new java.lang.String[] { }); + internal_static_Mysqlx_ServerMessages_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_Mysqlx_ServerMessages_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_ServerMessages_descriptor, + new java.lang.String[] { }); + internal_static_Mysqlx_Ok_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_Mysqlx_Ok_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Ok_descriptor, + new java.lang.String[] { "Msg", }); + internal_static_Mysqlx_Error_descriptor = + getDescriptor().getMessageTypes().get(3); + internal_static_Mysqlx_Error_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Error_descriptor, + new java.lang.String[] { "Severity", "Code", "SqlState", "Msg", }); + clientMessageId.internalInit(descriptor.getExtensions().get(0)); + serverMessageId.internalInit(descriptor.getExtensions().get(1)); + com.google.protobuf.ExtensionRegistry registry = + com.google.protobuf.ExtensionRegistry.newInstance(); + registry.add(com.mysql.cj.x.protobuf.Mysqlx.serverMessageId); + com.google.protobuf.Descriptors.FileDescriptor + .internalUpdateFileDescriptor(descriptor, registry); + com.google.protobuf.DescriptorProtos.getDescriptor(); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxConnection.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxConnection.java new file mode 100644 index 0000000..2cc4556 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxConnection.java @@ -0,0 +1,4175 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.x.protobuf; + +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: mysqlx_connection.proto + +@SuppressWarnings({ "deprecation" }) +public final class MysqlxConnection { + private MysqlxConnection() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + public interface CapabilityOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Connection.Capability) + com.google.protobuf.MessageOrBuilder { + + /** + * required string name = 1; + * @return Whether the name field is set. + */ + boolean hasName(); + /** + * required string name = 1; + * @return The name. + */ + java.lang.String getName(); + /** + * required string name = 1; + * @return The bytes for name. + */ + com.google.protobuf.ByteString + getNameBytes(); + + /** + * required .Mysqlx.Datatypes.Any value = 2; + * @return Whether the value field is set. + */ + boolean hasValue(); + /** + * required .Mysqlx.Datatypes.Any value = 2; + * @return The value. + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any getValue(); + /** + * required .Mysqlx.Datatypes.Any value = 2; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder getValueOrBuilder(); + } + /** + * 
+   **
+   *Capability
+   *A tuple of a ``name`` and a @ref Mysqlx::Datatypes::Any
+   *
+ * + * Protobuf type {@code Mysqlx.Connection.Capability} + */ + public static final class Capability extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Connection.Capability) + CapabilityOrBuilder { + private static final long serialVersionUID = 0L; + // Use Capability.newBuilder() to construct. + private Capability(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Capability() { + name_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Capability(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Capability( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000001; + name_ = bs; + break; + } + case 18: { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) != 0)) { + subBuilder = value_.toBuilder(); + } + value_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(value_); + value_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_Capability_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_Capability_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxConnection.Capability.class, com.mysql.cj.x.protobuf.MysqlxConnection.Capability.Builder.class); + } + + private int bitField0_; + public static final int NAME_FIELD_NUMBER = 1; + private volatile java.lang.Object name_; + /** + * required string name = 1; + * @return Whether the name field is set. + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required string name = 1; + * @return The name. + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } + } + /** + * required string name = 1; + * @return The bytes for name. + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int VALUE_FIELD_NUMBER = 2; + private com.mysql.cj.x.protobuf.MysqlxDatatypes.Any value_; + /** + * required .Mysqlx.Datatypes.Any value = 2; + * @return Whether the value field is set. + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * required .Mysqlx.Datatypes.Any value = 2; + * @return The value. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any getValue() { + return value_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.getDefaultInstance() : value_; + } + /** + * required .Mysqlx.Datatypes.Any value = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder getValueOrBuilder() { + return value_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.getDefaultInstance() : value_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasName()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasValue()) { + memoizedIsInitialized = 0; + return false; + } + if (!getValue().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, name_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeMessage(2, getValue()); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, name_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, getValue()); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxConnection.Capability)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxConnection.Capability other = (com.mysql.cj.x.protobuf.MysqlxConnection.Capability) obj; + + if (hasName() != other.hasName()) return false; + if (hasName()) { + if (!getName() + .equals(other.getName())) return false; + } + if (hasValue() != other.hasValue()) return false; + if (hasValue()) { + if (!getValue() + .equals(other.getValue())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasName()) { + hash = (37 * hash) + NAME_FIELD_NUMBER; + hash = (53 * hash) + getName().hashCode(); + } + if (hasValue()) { + hash = (37 * hash) + VALUE_FIELD_NUMBER; + hash = (53 * hash) + getValue().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capability parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capability parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capability parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capability parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capability parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capability parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capability parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capability parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capability parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capability parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capability parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capability parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxConnection.Capability prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Capability
+     *A tuple of a ``name`` and a @ref Mysqlx::Datatypes::Any
+     *
+ * + * Protobuf type {@code Mysqlx.Connection.Capability} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Connection.Capability) + com.mysql.cj.x.protobuf.MysqlxConnection.CapabilityOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_Capability_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_Capability_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxConnection.Capability.class, com.mysql.cj.x.protobuf.MysqlxConnection.Capability.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxConnection.Capability.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getValueFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + name_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + if (valueBuilder_ == null) { + value_ = null; + } else { + valueBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_Capability_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.Capability getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxConnection.Capability.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.Capability build() { + com.mysql.cj.x.protobuf.MysqlxConnection.Capability result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.Capability buildPartial() { + com.mysql.cj.x.protobuf.MysqlxConnection.Capability result = new com.mysql.cj.x.protobuf.MysqlxConnection.Capability(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.name_ = name_; + if (((from_bitField0_ & 0x00000002) != 0)) { + if (valueBuilder_ == null) { + result.value_ = value_; + } else { + result.value_ = valueBuilder_.build(); + } + to_bitField0_ |= 0x00000002; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxConnection.Capability) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxConnection.Capability)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxConnection.Capability other) { + if (other == com.mysql.cj.x.protobuf.MysqlxConnection.Capability.getDefaultInstance()) return this; + if (other.hasName()) { + bitField0_ |= 0x00000001; + name_ = other.name_; + onChanged(); + } + if (other.hasValue()) { + mergeValue(other.getValue()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasName()) { + return false; + } + if (!hasValue()) { + return false; + } + if (!getValue().isInitialized()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxConnection.Capability parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxConnection.Capability) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object name_ = ""; + /** + * required string name = 1; + * @return Whether the name field is set. + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required string name = 1; + * @return The name. + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string name = 1; + * @return The bytes for name. + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * required string name = 1; + * @param value The name to set. + * @return This builder for chaining. + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + name_ = value; + onChanged(); + return this; + } + /** + * required string name = 1; + * @return This builder for chaining. + */ + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000001); + name_ = getDefaultInstance().getName(); + onChanged(); + return this; + } + /** + * required string name = 1; + * @param value The bytes for name to set. + * @return This builder for chaining. + */ + public Builder setNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + name_ = value; + onChanged(); + return this; + } + + private com.mysql.cj.x.protobuf.MysqlxDatatypes.Any value_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder> valueBuilder_; + /** + * required .Mysqlx.Datatypes.Any value = 2; + * @return Whether the value field is set. + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * required .Mysqlx.Datatypes.Any value = 2; + * @return The value. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any getValue() { + if (valueBuilder_ == null) { + return value_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.getDefaultInstance() : value_; + } else { + return valueBuilder_.getMessage(); + } + } + /** + * required .Mysqlx.Datatypes.Any value = 2; + */ + public Builder setValue(com.mysql.cj.x.protobuf.MysqlxDatatypes.Any value) { + if (valueBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + value_ = value; + onChanged(); + } else { + valueBuilder_.setMessage(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * required .Mysqlx.Datatypes.Any value = 2; + */ + public Builder setValue( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder builderForValue) { + if (valueBuilder_ == null) { + value_ = builderForValue.build(); + onChanged(); + } else { + valueBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * required .Mysqlx.Datatypes.Any value = 2; + */ + public Builder mergeValue(com.mysql.cj.x.protobuf.MysqlxDatatypes.Any value) { + if (valueBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0) && + value_ != null && + value_ != com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.getDefaultInstance()) { + value_ = + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.newBuilder(value_).mergeFrom(value).buildPartial(); + } else { + value_ = value; + } + onChanged(); + } else { + valueBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * required .Mysqlx.Datatypes.Any value = 2; + */ + public Builder clearValue() { + if (valueBuilder_ == null) { + value_ = null; + onChanged(); + } else { + valueBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + /** + * required .Mysqlx.Datatypes.Any value = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder getValueBuilder() { + bitField0_ |= 0x00000002; + onChanged(); + return getValueFieldBuilder().getBuilder(); + } + /** + * required .Mysqlx.Datatypes.Any value = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder getValueOrBuilder() { + if (valueBuilder_ != null) { + return valueBuilder_.getMessageOrBuilder(); + } else { + return value_ == null ? + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.getDefaultInstance() : value_; + } + } + /** + * required .Mysqlx.Datatypes.Any value = 2; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder> + getValueFieldBuilder() { + if (valueBuilder_ == null) { + valueBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder>( + getValue(), + getParentForChildren(), + isClean()); + value_ = null; + } + return valueBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Connection.Capability) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Connection.Capability) + private static final com.mysql.cj.x.protobuf.MysqlxConnection.Capability DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxConnection.Capability(); + } + + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capability getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Capability parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Capability(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.Capability getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface CapabilitiesOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Connection.Capabilities) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + java.util.List + getCapabilitiesList(); + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + com.mysql.cj.x.protobuf.MysqlxConnection.Capability getCapabilities(int index); + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + int getCapabilitiesCount(); + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + java.util.List + getCapabilitiesOrBuilderList(); + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + com.mysql.cj.x.protobuf.MysqlxConnection.CapabilityOrBuilder getCapabilitiesOrBuilder( + int index); + } + /** + * 
+   **
+   *Capabilities
+   *list of Capability
+   *
+ * + * Protobuf type {@code Mysqlx.Connection.Capabilities} + */ + public static final class Capabilities extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Connection.Capabilities) + CapabilitiesOrBuilder { + private static final long serialVersionUID = 0L; + // Use Capabilities.newBuilder() to construct. + private Capabilities(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Capabilities() { + capabilities_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Capabilities(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Capabilities( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + if (!((mutable_bitField0_ & 0x00000001) != 0)) { + capabilities_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + capabilities_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxConnection.Capability.PARSER, extensionRegistry)); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000001) != 0)) { + capabilities_ = java.util.Collections.unmodifiableList(capabilities_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_Capabilities_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_Capabilities_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities.class, com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities.Builder.class); + } + + public static final int CAPABILITIES_FIELD_NUMBER = 1; + private java.util.List capabilities_; + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public java.util.List getCapabilitiesList() { + return capabilities_; + } + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public java.util.List + getCapabilitiesOrBuilderList() { + return capabilities_; + } + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public int getCapabilitiesCount() { + return capabilities_.size(); + } + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxConnection.Capability getCapabilities(int index) { + return capabilities_.get(index); + } + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxConnection.CapabilityOrBuilder getCapabilitiesOrBuilder( + int index) { + return capabilities_.get(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + for (int i = 0; i < getCapabilitiesCount(); i++) { + if (!getCapabilities(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < capabilities_.size(); i++) { + output.writeMessage(1, capabilities_.get(i)); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < capabilities_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, capabilities_.get(i)); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities other = (com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities) obj; + + if (!getCapabilitiesList() + .equals(other.getCapabilitiesList())) return false; + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getCapabilitiesCount() > 0) { + hash = (37 * hash) + CAPABILITIES_FIELD_NUMBER; + hash = (53 * hash) + getCapabilitiesList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Capabilities
+     *list of Capability
+     *
+ * + * Protobuf type {@code Mysqlx.Connection.Capabilities} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Connection.Capabilities) + com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_Capabilities_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_Capabilities_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities.class, com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getCapabilitiesFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + if (capabilitiesBuilder_ == null) { + capabilities_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + } else { + capabilitiesBuilder_.clear(); + } + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_Capabilities_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities build() { + com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities buildPartial() { + com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities result = new com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities(this); + int from_bitField0_ = bitField0_; + if (capabilitiesBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0)) { + capabilities_ = java.util.Collections.unmodifiableList(capabilities_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.capabilities_ = capabilities_; + } else { + result.capabilities_ = capabilitiesBuilder_.build(); + } + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities other) { + if (other == com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities.getDefaultInstance()) return this; + if (capabilitiesBuilder_ == null) { + if (!other.capabilities_.isEmpty()) { + if (capabilities_.isEmpty()) { + capabilities_ = other.capabilities_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureCapabilitiesIsMutable(); + capabilities_.addAll(other.capabilities_); + } + onChanged(); + } + } else { + if (!other.capabilities_.isEmpty()) { + if (capabilitiesBuilder_.isEmpty()) { + capabilitiesBuilder_.dispose(); + capabilitiesBuilder_ = null; + capabilities_ = other.capabilities_; + bitField0_ = (bitField0_ & ~0x00000001); + capabilitiesBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getCapabilitiesFieldBuilder() : null; + } else { + capabilitiesBuilder_.addAllMessages(other.capabilities_); + } + } + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + for (int i = 0; i < getCapabilitiesCount(); i++) { + if (!getCapabilities(i).isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List capabilities_ = + java.util.Collections.emptyList(); + private void ensureCapabilitiesIsMutable() { + if (!((bitField0_ & 0x00000001) != 0)) { + capabilities_ = new java.util.ArrayList(capabilities_); + bitField0_ |= 0x00000001; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxConnection.Capability, com.mysql.cj.x.protobuf.MysqlxConnection.Capability.Builder, com.mysql.cj.x.protobuf.MysqlxConnection.CapabilityOrBuilder> capabilitiesBuilder_; + + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public java.util.List getCapabilitiesList() { + if (capabilitiesBuilder_ == null) { + return java.util.Collections.unmodifiableList(capabilities_); + } else { + return capabilitiesBuilder_.getMessageList(); + } + } + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public int getCapabilitiesCount() { + if (capabilitiesBuilder_ == null) { + return capabilities_.size(); + } else { + return capabilitiesBuilder_.getCount(); + } + } + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxConnection.Capability getCapabilities(int index) { + if (capabilitiesBuilder_ == null) { + return capabilities_.get(index); + } else { + return capabilitiesBuilder_.getMessage(index); + } + } + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public Builder setCapabilities( + int index, com.mysql.cj.x.protobuf.MysqlxConnection.Capability value) { + if (capabilitiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureCapabilitiesIsMutable(); + capabilities_.set(index, value); + onChanged(); + } else { + capabilitiesBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public Builder setCapabilities( + int index, com.mysql.cj.x.protobuf.MysqlxConnection.Capability.Builder builderForValue) { + if (capabilitiesBuilder_ == null) { + ensureCapabilitiesIsMutable(); + capabilities_.set(index, builderForValue.build()); + onChanged(); + } else { + capabilitiesBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public Builder addCapabilities(com.mysql.cj.x.protobuf.MysqlxConnection.Capability value) { + if (capabilitiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureCapabilitiesIsMutable(); + capabilities_.add(value); + onChanged(); + } else { + capabilitiesBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public Builder addCapabilities( + int index, com.mysql.cj.x.protobuf.MysqlxConnection.Capability value) { + if (capabilitiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureCapabilitiesIsMutable(); + capabilities_.add(index, value); + onChanged(); + } else { + capabilitiesBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public Builder addCapabilities( + com.mysql.cj.x.protobuf.MysqlxConnection.Capability.Builder builderForValue) { + if (capabilitiesBuilder_ == null) { + ensureCapabilitiesIsMutable(); + capabilities_.add(builderForValue.build()); + onChanged(); + } else { + capabilitiesBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public Builder addCapabilities( + int index, com.mysql.cj.x.protobuf.MysqlxConnection.Capability.Builder builderForValue) { + if (capabilitiesBuilder_ == null) { + ensureCapabilitiesIsMutable(); + capabilities_.add(index, builderForValue.build()); + onChanged(); + } else { + capabilitiesBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public Builder addAllCapabilities( + java.lang.Iterable values) { + if (capabilitiesBuilder_ == null) { + ensureCapabilitiesIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, capabilities_); + onChanged(); + } else { + capabilitiesBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public Builder clearCapabilities() { + if (capabilitiesBuilder_ == null) { + capabilities_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + } else { + capabilitiesBuilder_.clear(); + } + return this; + } + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public Builder removeCapabilities(int index) { + if (capabilitiesBuilder_ == null) { + ensureCapabilitiesIsMutable(); + capabilities_.remove(index); + onChanged(); + } else { + capabilitiesBuilder_.remove(index); + } + return this; + } + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxConnection.Capability.Builder getCapabilitiesBuilder( + int index) { + return getCapabilitiesFieldBuilder().getBuilder(index); + } + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxConnection.CapabilityOrBuilder getCapabilitiesOrBuilder( + int index) { + if (capabilitiesBuilder_ == null) { + return capabilities_.get(index); } else { + return capabilitiesBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public java.util.List + getCapabilitiesOrBuilderList() { + if (capabilitiesBuilder_ != null) { + return capabilitiesBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(capabilities_); + } + } + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxConnection.Capability.Builder addCapabilitiesBuilder() { + return getCapabilitiesFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxConnection.Capability.getDefaultInstance()); + } + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxConnection.Capability.Builder addCapabilitiesBuilder( + int index) { + return getCapabilitiesFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxConnection.Capability.getDefaultInstance()); + } + /** + * repeated .Mysqlx.Connection.Capability capabilities = 1; + */ + public java.util.List + getCapabilitiesBuilderList() { + return getCapabilitiesFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxConnection.Capability, com.mysql.cj.x.protobuf.MysqlxConnection.Capability.Builder, com.mysql.cj.x.protobuf.MysqlxConnection.CapabilityOrBuilder> + getCapabilitiesFieldBuilder() { + if (capabilitiesBuilder_ == null) { + capabilitiesBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxConnection.Capability, com.mysql.cj.x.protobuf.MysqlxConnection.Capability.Builder, com.mysql.cj.x.protobuf.MysqlxConnection.CapabilityOrBuilder>( + capabilities_, + ((bitField0_ & 0x00000001) != 0), + getParentForChildren(), + isClean()); + capabilities_ = null; + } + return capabilitiesBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Connection.Capabilities) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Connection.Capabilities) + private static final com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities(); + } + + public static com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Capabilities parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Capabilities(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface CapabilitiesGetOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Connection.CapabilitiesGet) + com.google.protobuf.MessageOrBuilder { + } + /** + * 
+   **
+   *Get supported connection capabilities and their current state.
+   *@returns @ref Mysqlx::Connection::Capabilities or @ref Mysqlx::Error
+   *
+ * + * Protobuf type {@code Mysqlx.Connection.CapabilitiesGet} + */ + public static final class CapabilitiesGet extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Connection.CapabilitiesGet) + CapabilitiesGetOrBuilder { + private static final long serialVersionUID = 0L; + // Use CapabilitiesGet.newBuilder() to construct. + private CapabilitiesGet(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private CapabilitiesGet() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new CapabilitiesGet(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private CapabilitiesGet( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_CapabilitiesGet_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_CapabilitiesGet_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet.class, com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet.Builder.class); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet other = (com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet) obj; + + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Get supported connection capabilities and their current state.
+     *@returns @ref Mysqlx::Connection::Capabilities or @ref Mysqlx::Error
+     *
+ * + * Protobuf type {@code Mysqlx.Connection.CapabilitiesGet} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Connection.CapabilitiesGet) + com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGetOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_CapabilitiesGet_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_CapabilitiesGet_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet.class, com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_CapabilitiesGet_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet build() { + com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet buildPartial() { + com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet result = new com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet(this); + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet other) { + if (other == com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet.getDefaultInstance()) return this; + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Connection.CapabilitiesGet) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Connection.CapabilitiesGet) + private static final com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet(); + } + + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public CapabilitiesGet parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new CapabilitiesGet(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesGet getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface CapabilitiesSetOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Connection.CapabilitiesSet) + com.google.protobuf.MessageOrBuilder { + + /** + * required .Mysqlx.Connection.Capabilities capabilities = 1; + * @return Whether the capabilities field is set. + */ + boolean hasCapabilities(); + /** + * required .Mysqlx.Connection.Capabilities capabilities = 1; + * @return The capabilities. + */ + com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities getCapabilities(); + /** + * required .Mysqlx.Connection.Capabilities capabilities = 1; + */ + com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesOrBuilder getCapabilitiesOrBuilder(); + } + /** + * 
+   **
+   *Set connection capabilities atomically.
+   *Only provided values are changed, other values are left
+   *unchanged. If any of the changes fails, all changes are
+   *discarded.
+   *@pre active sessions == 0
+   *@returns @ref Mysqlx::Ok  or @ref Mysqlx::Error
+   *
+ * + * Protobuf type {@code Mysqlx.Connection.CapabilitiesSet} + */ + public static final class CapabilitiesSet extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Connection.CapabilitiesSet) + CapabilitiesSetOrBuilder { + private static final long serialVersionUID = 0L; + // Use CapabilitiesSet.newBuilder() to construct. + private CapabilitiesSet(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private CapabilitiesSet() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new CapabilitiesSet(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private CapabilitiesSet( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) != 0)) { + subBuilder = capabilities_.toBuilder(); + } + capabilities_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(capabilities_); + capabilities_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_CapabilitiesSet_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_CapabilitiesSet_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet.class, com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet.Builder.class); + } + + private int bitField0_; + public static final int CAPABILITIES_FIELD_NUMBER = 1; + private com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities capabilities_; + /** + * required .Mysqlx.Connection.Capabilities capabilities = 1; + * @return Whether the capabilities field is set. + */ + public boolean hasCapabilities() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required .Mysqlx.Connection.Capabilities capabilities = 1; + * @return The capabilities. + */ + public com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities getCapabilities() { + return capabilities_ == null ? com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities.getDefaultInstance() : capabilities_; + } + /** + * required .Mysqlx.Connection.Capabilities capabilities = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesOrBuilder getCapabilitiesOrBuilder() { + return capabilities_ == null ? com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities.getDefaultInstance() : capabilities_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasCapabilities()) { + memoizedIsInitialized = 0; + return false; + } + if (!getCapabilities().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeMessage(1, getCapabilities()); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, getCapabilities()); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet other = (com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet) obj; + + if (hasCapabilities() != other.hasCapabilities()) return false; + if (hasCapabilities()) { + if (!getCapabilities() + .equals(other.getCapabilities())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasCapabilities()) { + hash = (37 * hash) + CAPABILITIES_FIELD_NUMBER; + hash = (53 * hash) + getCapabilities().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Set connection capabilities atomically.
+     *Only provided values are changed, other values are left
+     *unchanged. If any of the changes fails, all changes are
+     *discarded.
+     *@pre active sessions == 0
+     *@returns @ref Mysqlx::Ok  or @ref Mysqlx::Error
+     *
+ * + * Protobuf type {@code Mysqlx.Connection.CapabilitiesSet} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Connection.CapabilitiesSet) + com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSetOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_CapabilitiesSet_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_CapabilitiesSet_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet.class, com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getCapabilitiesFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + if (capabilitiesBuilder_ == null) { + capabilities_ = null; + } else { + capabilitiesBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_CapabilitiesSet_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet build() { + com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet buildPartial() { + com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet result = new com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + if (capabilitiesBuilder_ == null) { + result.capabilities_ = capabilities_; + } else { + result.capabilities_ = capabilitiesBuilder_.build(); + } + to_bitField0_ |= 0x00000001; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet other) { + if (other == com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet.getDefaultInstance()) return this; + if (other.hasCapabilities()) { + mergeCapabilities(other.getCapabilities()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasCapabilities()) { + return false; + } + if (!getCapabilities().isInitialized()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities capabilities_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities, com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities.Builder, com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesOrBuilder> capabilitiesBuilder_; + /** + * required .Mysqlx.Connection.Capabilities capabilities = 1; + * @return Whether the capabilities field is set. + */ + public boolean hasCapabilities() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required .Mysqlx.Connection.Capabilities capabilities = 1; + * @return The capabilities. + */ + public com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities getCapabilities() { + if (capabilitiesBuilder_ == null) { + return capabilities_ == null ? com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities.getDefaultInstance() : capabilities_; + } else { + return capabilitiesBuilder_.getMessage(); + } + } + /** + * required .Mysqlx.Connection.Capabilities capabilities = 1; + */ + public Builder setCapabilities(com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities value) { + if (capabilitiesBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + capabilities_ = value; + onChanged(); + } else { + capabilitiesBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * required .Mysqlx.Connection.Capabilities capabilities = 1; + */ + public Builder setCapabilities( + com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities.Builder builderForValue) { + if (capabilitiesBuilder_ == null) { + capabilities_ = builderForValue.build(); + onChanged(); + } else { + capabilitiesBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * required .Mysqlx.Connection.Capabilities capabilities = 1; + */ + public Builder mergeCapabilities(com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities value) { + if (capabilitiesBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0) && + capabilities_ != null && + capabilities_ != com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities.getDefaultInstance()) { + capabilities_ = + com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities.newBuilder(capabilities_).mergeFrom(value).buildPartial(); + } else { + capabilities_ = value; + } + onChanged(); + } else { + capabilitiesBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * required .Mysqlx.Connection.Capabilities capabilities = 1; + */ + public Builder clearCapabilities() { + if (capabilitiesBuilder_ == null) { + capabilities_ = null; + onChanged(); + } else { + capabilitiesBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + /** + * required .Mysqlx.Connection.Capabilities capabilities = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities.Builder getCapabilitiesBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getCapabilitiesFieldBuilder().getBuilder(); + } + /** + * required .Mysqlx.Connection.Capabilities capabilities = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesOrBuilder getCapabilitiesOrBuilder() { + if (capabilitiesBuilder_ != null) { + return capabilitiesBuilder_.getMessageOrBuilder(); + } else { + return capabilities_ == null ? + com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities.getDefaultInstance() : capabilities_; + } + } + /** + * required .Mysqlx.Connection.Capabilities capabilities = 1; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities, com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities.Builder, com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesOrBuilder> + getCapabilitiesFieldBuilder() { + if (capabilitiesBuilder_ == null) { + capabilitiesBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities, com.mysql.cj.x.protobuf.MysqlxConnection.Capabilities.Builder, com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesOrBuilder>( + getCapabilities(), + getParentForChildren(), + isClean()); + capabilities_ = null; + } + return capabilitiesBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Connection.CapabilitiesSet) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Connection.CapabilitiesSet) + private static final com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet(); + } + + public static com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public CapabilitiesSet parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new CapabilitiesSet(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.CapabilitiesSet getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface CloseOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Connection.Close) + com.google.protobuf.MessageOrBuilder { + } + /** + * 
+   **
+   *Announce to the server that the client wants to close the connection.
+   *It discards any session state of the server.
+   *@returns @ref Mysqlx::Ok
+   *
+ * + * Protobuf type {@code Mysqlx.Connection.Close} + */ + public static final class Close extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Connection.Close) + CloseOrBuilder { + private static final long serialVersionUID = 0L; + // Use Close.newBuilder() to construct. + private Close(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Close() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Close(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Close( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_Close_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_Close_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxConnection.Close.class, com.mysql.cj.x.protobuf.MysqlxConnection.Close.Builder.class); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxConnection.Close)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxConnection.Close other = (com.mysql.cj.x.protobuf.MysqlxConnection.Close) obj; + + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxConnection.Close parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Close parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Close parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Close parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Close parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Close parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Close parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Close parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Close parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Close parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Close parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Close parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxConnection.Close prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Announce to the server that the client wants to close the connection.
+     *It discards any session state of the server.
+     *@returns @ref Mysqlx::Ok
+     *
+ * + * Protobuf type {@code Mysqlx.Connection.Close} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Connection.Close) + com.mysql.cj.x.protobuf.MysqlxConnection.CloseOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_Close_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_Close_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxConnection.Close.class, com.mysql.cj.x.protobuf.MysqlxConnection.Close.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxConnection.Close.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_Close_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.Close getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxConnection.Close.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.Close build() { + com.mysql.cj.x.protobuf.MysqlxConnection.Close result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.Close buildPartial() { + com.mysql.cj.x.protobuf.MysqlxConnection.Close result = new com.mysql.cj.x.protobuf.MysqlxConnection.Close(this); + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxConnection.Close) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxConnection.Close)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxConnection.Close other) { + if (other == com.mysql.cj.x.protobuf.MysqlxConnection.Close.getDefaultInstance()) return this; + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxConnection.Close parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxConnection.Close) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Connection.Close) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Connection.Close) + private static final com.mysql.cj.x.protobuf.MysqlxConnection.Close DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxConnection.Close(); + } + + public static com.mysql.cj.x.protobuf.MysqlxConnection.Close getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Close parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Close(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.Close getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface CompressionOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Connection.Compression) + com.google.protobuf.MessageOrBuilder { + + /** + * optional uint64 uncompressed_size = 1; + * @return Whether the uncompressedSize field is set. + */ + boolean hasUncompressedSize(); + /** + * optional uint64 uncompressed_size = 1; + * @return The uncompressedSize. + */ + long getUncompressedSize(); + + /** + * optional .Mysqlx.ServerMessages.Type server_messages = 2; + * @return Whether the serverMessages field is set. + */ + boolean hasServerMessages(); + /** + * optional .Mysqlx.ServerMessages.Type server_messages = 2; + * @return The serverMessages. + */ + com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.Type getServerMessages(); + + /** + * optional .Mysqlx.ClientMessages.Type client_messages = 3; + * @return Whether the clientMessages field is set. + */ + boolean hasClientMessages(); + /** + * optional .Mysqlx.ClientMessages.Type client_messages = 3; + * @return The clientMessages. + */ + com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.Type getClientMessages(); + + /** + * required bytes payload = 4; + * @return Whether the payload field is set. + */ + boolean hasPayload(); + /** + * required bytes payload = 4; + * @return The payload. + */ + com.google.protobuf.ByteString getPayload(); + } + /** + * Protobuf type {@code Mysqlx.Connection.Compression} + */ + public static final class Compression extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Connection.Compression) + CompressionOrBuilder { + private static final long serialVersionUID = 0L; + // Use Compression.newBuilder() to construct. + private Compression(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Compression() { + serverMessages_ = 0; + clientMessages_ = 1; + payload_ = com.google.protobuf.ByteString.EMPTY; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Compression(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Compression( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + bitField0_ |= 0x00000001; + uncompressedSize_ = input.readUInt64(); + break; + } + case 16: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.Type value = com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.Type.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(2, rawValue); + } else { + bitField0_ |= 0x00000002; + serverMessages_ = rawValue; + } + break; + } + case 24: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.Type value = com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.Type.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(3, rawValue); + } else { + bitField0_ |= 0x00000004; + clientMessages_ = rawValue; + } + break; + } + case 34: { + bitField0_ |= 0x00000008; + payload_ = input.readBytes(); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_Compression_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_Compression_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxConnection.Compression.class, com.mysql.cj.x.protobuf.MysqlxConnection.Compression.Builder.class); + } + + private int bitField0_; + public static final int UNCOMPRESSED_SIZE_FIELD_NUMBER = 1; + private long uncompressedSize_; + /** + * optional uint64 uncompressed_size = 1; + * @return Whether the uncompressedSize field is set. + */ + public boolean hasUncompressedSize() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * optional uint64 uncompressed_size = 1; + * @return The uncompressedSize. + */ + public long getUncompressedSize() { + return uncompressedSize_; + } + + public static final int SERVER_MESSAGES_FIELD_NUMBER = 2; + private int serverMessages_; + /** + * optional .Mysqlx.ServerMessages.Type server_messages = 2; + * @return Whether the serverMessages field is set. + */ + public boolean hasServerMessages() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional .Mysqlx.ServerMessages.Type server_messages = 2; + * @return The serverMessages. + */ + public com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.Type getServerMessages() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.Type result = com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.Type.valueOf(serverMessages_); + return result == null ? com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.Type.OK : result; + } + + public static final int CLIENT_MESSAGES_FIELD_NUMBER = 3; + private int clientMessages_; + /** + * optional .Mysqlx.ClientMessages.Type client_messages = 3; + * @return Whether the clientMessages field is set. + */ + public boolean hasClientMessages() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * optional .Mysqlx.ClientMessages.Type client_messages = 3; + * @return The clientMessages. + */ + public com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.Type getClientMessages() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.Type result = com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.Type.valueOf(clientMessages_); + return result == null ? com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.Type.CON_CAPABILITIES_GET : result; + } + + public static final int PAYLOAD_FIELD_NUMBER = 4; + private com.google.protobuf.ByteString payload_; + /** + * required bytes payload = 4; + * @return Whether the payload field is set. + */ + public boolean hasPayload() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * required bytes payload = 4; + * @return The payload. + */ + public com.google.protobuf.ByteString getPayload() { + return payload_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasPayload()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeUInt64(1, uncompressedSize_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeEnum(2, serverMessages_); + } + if (((bitField0_ & 0x00000004) != 0)) { + output.writeEnum(3, clientMessages_); + } + if (((bitField0_ & 0x00000008) != 0)) { + output.writeBytes(4, payload_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt64Size(1, uncompressedSize_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(2, serverMessages_); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(3, clientMessages_); + } + if (((bitField0_ & 0x00000008) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(4, payload_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxConnection.Compression)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxConnection.Compression other = (com.mysql.cj.x.protobuf.MysqlxConnection.Compression) obj; + + if (hasUncompressedSize() != other.hasUncompressedSize()) return false; + if (hasUncompressedSize()) { + if (getUncompressedSize() + != other.getUncompressedSize()) return false; + } + if (hasServerMessages() != other.hasServerMessages()) return false; + if (hasServerMessages()) { + if (serverMessages_ != other.serverMessages_) return false; + } + if (hasClientMessages() != other.hasClientMessages()) return false; + if (hasClientMessages()) { + if (clientMessages_ != other.clientMessages_) return false; + } + if (hasPayload() != other.hasPayload()) return false; + if (hasPayload()) { + if (!getPayload() + .equals(other.getPayload())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasUncompressedSize()) { + hash = (37 * hash) + UNCOMPRESSED_SIZE_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getUncompressedSize()); + } + if (hasServerMessages()) { + hash = (37 * hash) + SERVER_MESSAGES_FIELD_NUMBER; + hash = (53 * hash) + serverMessages_; + } + if (hasClientMessages()) { + hash = (37 * hash) + CLIENT_MESSAGES_FIELD_NUMBER; + hash = (53 * hash) + clientMessages_; + } + if (hasPayload()) { + hash = (37 * hash) + PAYLOAD_FIELD_NUMBER; + hash = (53 * hash) + getPayload().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxConnection.Compression parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Compression parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Compression parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Compression parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Compression parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Compression parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Compression parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Compression parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Compression parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Compression parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Compression parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxConnection.Compression parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxConnection.Compression prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Mysqlx.Connection.Compression} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Connection.Compression) + com.mysql.cj.x.protobuf.MysqlxConnection.CompressionOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_Compression_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_Compression_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxConnection.Compression.class, com.mysql.cj.x.protobuf.MysqlxConnection.Compression.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxConnection.Compression.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + uncompressedSize_ = 0L; + bitField0_ = (bitField0_ & ~0x00000001); + serverMessages_ = 0; + bitField0_ = (bitField0_ & ~0x00000002); + clientMessages_ = 1; + bitField0_ = (bitField0_ & ~0x00000004); + payload_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxConnection.internal_static_Mysqlx_Connection_Compression_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.Compression getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxConnection.Compression.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.Compression build() { + com.mysql.cj.x.protobuf.MysqlxConnection.Compression result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.Compression buildPartial() { + com.mysql.cj.x.protobuf.MysqlxConnection.Compression result = new com.mysql.cj.x.protobuf.MysqlxConnection.Compression(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.uncompressedSize_ = uncompressedSize_; + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + to_bitField0_ |= 0x00000002; + } + result.serverMessages_ = serverMessages_; + if (((from_bitField0_ & 0x00000004) != 0)) { + to_bitField0_ |= 0x00000004; + } + result.clientMessages_ = clientMessages_; + if (((from_bitField0_ & 0x00000008) != 0)) { + to_bitField0_ |= 0x00000008; + } + result.payload_ = payload_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxConnection.Compression) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxConnection.Compression)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxConnection.Compression other) { + if (other == com.mysql.cj.x.protobuf.MysqlxConnection.Compression.getDefaultInstance()) return this; + if (other.hasUncompressedSize()) { + setUncompressedSize(other.getUncompressedSize()); + } + if (other.hasServerMessages()) { + setServerMessages(other.getServerMessages()); + } + if (other.hasClientMessages()) { + setClientMessages(other.getClientMessages()); + } + if (other.hasPayload()) { + setPayload(other.getPayload()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasPayload()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxConnection.Compression parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxConnection.Compression) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private long uncompressedSize_ ; + /** + * optional uint64 uncompressed_size = 1; + * @return Whether the uncompressedSize field is set. + */ + public boolean hasUncompressedSize() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * optional uint64 uncompressed_size = 1; + * @return The uncompressedSize. + */ + public long getUncompressedSize() { + return uncompressedSize_; + } + /** + * optional uint64 uncompressed_size = 1; + * @param value The uncompressedSize to set. + * @return This builder for chaining. + */ + public Builder setUncompressedSize(long value) { + bitField0_ |= 0x00000001; + uncompressedSize_ = value; + onChanged(); + return this; + } + /** + * optional uint64 uncompressed_size = 1; + * @return This builder for chaining. + */ + public Builder clearUncompressedSize() { + bitField0_ = (bitField0_ & ~0x00000001); + uncompressedSize_ = 0L; + onChanged(); + return this; + } + + private int serverMessages_ = 0; + /** + * optional .Mysqlx.ServerMessages.Type server_messages = 2; + * @return Whether the serverMessages field is set. + */ + public boolean hasServerMessages() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional .Mysqlx.ServerMessages.Type server_messages = 2; + * @return The serverMessages. + */ + public com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.Type getServerMessages() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.Type result = com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.Type.valueOf(serverMessages_); + return result == null ? com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.Type.OK : result; + } + /** + * optional .Mysqlx.ServerMessages.Type server_messages = 2; + * @param value The serverMessages to set. + * @return This builder for chaining. + */ + public Builder setServerMessages(com.mysql.cj.x.protobuf.Mysqlx.ServerMessages.Type value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + serverMessages_ = value.getNumber(); + onChanged(); + return this; + } + /** + * optional .Mysqlx.ServerMessages.Type server_messages = 2; + * @return This builder for chaining. + */ + public Builder clearServerMessages() { + bitField0_ = (bitField0_ & ~0x00000002); + serverMessages_ = 0; + onChanged(); + return this; + } + + private int clientMessages_ = 1; + /** + * optional .Mysqlx.ClientMessages.Type client_messages = 3; + * @return Whether the clientMessages field is set. + */ + public boolean hasClientMessages() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * optional .Mysqlx.ClientMessages.Type client_messages = 3; + * @return The clientMessages. + */ + public com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.Type getClientMessages() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.Type result = com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.Type.valueOf(clientMessages_); + return result == null ? com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.Type.CON_CAPABILITIES_GET : result; + } + /** + * optional .Mysqlx.ClientMessages.Type client_messages = 3; + * @param value The clientMessages to set. + * @return This builder for chaining. + */ + public Builder setClientMessages(com.mysql.cj.x.protobuf.Mysqlx.ClientMessages.Type value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + clientMessages_ = value.getNumber(); + onChanged(); + return this; + } + /** + * optional .Mysqlx.ClientMessages.Type client_messages = 3; + * @return This builder for chaining. + */ + public Builder clearClientMessages() { + bitField0_ = (bitField0_ & ~0x00000004); + clientMessages_ = 1; + onChanged(); + return this; + } + + private com.google.protobuf.ByteString payload_ = com.google.protobuf.ByteString.EMPTY; + /** + * required bytes payload = 4; + * @return Whether the payload field is set. + */ + public boolean hasPayload() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * required bytes payload = 4; + * @return The payload. + */ + public com.google.protobuf.ByteString getPayload() { + return payload_; + } + /** + * required bytes payload = 4; + * @param value The payload to set. + * @return This builder for chaining. + */ + public Builder setPayload(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + payload_ = value; + onChanged(); + return this; + } + /** + * required bytes payload = 4; + * @return This builder for chaining. + */ + public Builder clearPayload() { + bitField0_ = (bitField0_ & ~0x00000008); + payload_ = getDefaultInstance().getPayload(); + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Connection.Compression) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Connection.Compression) + private static final com.mysql.cj.x.protobuf.MysqlxConnection.Compression DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxConnection.Compression(); + } + + public static com.mysql.cj.x.protobuf.MysqlxConnection.Compression getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Compression parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Compression(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxConnection.Compression getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Connection_Capability_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Connection_Capability_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Connection_Capabilities_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Connection_Capabilities_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Connection_CapabilitiesGet_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Connection_CapabilitiesGet_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Connection_CapabilitiesSet_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Connection_CapabilitiesSet_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Connection_Close_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Connection_Close_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Connection_Compression_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Connection_Compression_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\027mysqlx_connection.proto\022\021Mysqlx.Connec" + + "tion\032\026mysqlx_datatypes.proto\032\014mysqlx.pro" + + "to\"@\n\nCapability\022\014\n\004name\030\001 \002(\t\022$\n\005value\030" + + "\002 \002(\0132\025.Mysqlx.Datatypes.Any\"I\n\014Capabili" + + "ties\0223\n\014capabilities\030\001 \003(\0132\035.Mysqlx.Conn" + + "ection.Capability:\004\220\3520\002\"\027\n\017CapabilitiesG" + + "et:\004\210\3520\001\"N\n\017CapabilitiesSet\0225\n\014capabilit" + + "ies\030\001 \002(\0132\037.Mysqlx.Connection.Capabiliti" + + "es:\004\210\3520\002\"\r\n\005Close:\004\210\3520\003\"\257\001\n\013Compression\022" + + "\031\n\021uncompressed_size\030\001 \001(\004\0224\n\017server_mes" + + "sages\030\002 \001(\0162\033.Mysqlx.ServerMessages.Type" + + "\0224\n\017client_messages\030\003 \001(\0162\033.Mysqlx.Clien" + + "tMessages.Type\022\017\n\007payload\030\004 \002(\014:\010\220\3520\023\210\3520" + + ".B\031\n\027com.mysql.cj.x.protobuf" + }; + descriptor = com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + com.mysql.cj.x.protobuf.MysqlxDatatypes.getDescriptor(), + com.mysql.cj.x.protobuf.Mysqlx.getDescriptor(), + }); + internal_static_Mysqlx_Connection_Capability_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_Mysqlx_Connection_Capability_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Connection_Capability_descriptor, + new java.lang.String[] { "Name", "Value", }); + internal_static_Mysqlx_Connection_Capabilities_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_Mysqlx_Connection_Capabilities_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Connection_Capabilities_descriptor, + new java.lang.String[] { "Capabilities", }); + internal_static_Mysqlx_Connection_CapabilitiesGet_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_Mysqlx_Connection_CapabilitiesGet_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Connection_CapabilitiesGet_descriptor, + new java.lang.String[] { }); + internal_static_Mysqlx_Connection_CapabilitiesSet_descriptor = + getDescriptor().getMessageTypes().get(3); + internal_static_Mysqlx_Connection_CapabilitiesSet_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Connection_CapabilitiesSet_descriptor, + new java.lang.String[] { "Capabilities", }); + internal_static_Mysqlx_Connection_Close_descriptor = + getDescriptor().getMessageTypes().get(4); + internal_static_Mysqlx_Connection_Close_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Connection_Close_descriptor, + new java.lang.String[] { }); + internal_static_Mysqlx_Connection_Compression_descriptor = + getDescriptor().getMessageTypes().get(5); + internal_static_Mysqlx_Connection_Compression_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Connection_Compression_descriptor, + new java.lang.String[] { "UncompressedSize", "ServerMessages", "ClientMessages", "Payload", }); + com.google.protobuf.ExtensionRegistry registry = + com.google.protobuf.ExtensionRegistry.newInstance(); + registry.add(com.mysql.cj.x.protobuf.Mysqlx.clientMessageId); + registry.add(com.mysql.cj.x.protobuf.Mysqlx.serverMessageId); + com.google.protobuf.Descriptors.FileDescriptor + .internalUpdateFileDescriptor(descriptor, registry); + com.mysql.cj.x.protobuf.MysqlxDatatypes.getDescriptor(); + com.mysql.cj.x.protobuf.Mysqlx.getDescriptor(); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxCrud.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxCrud.java new file mode 100644 index 0000000..3c363c4 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxCrud.java @@ -0,0 +1,26227 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.x.protobuf; + +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: mysqlx_crud.proto + +@SuppressWarnings({ "deprecation" }) +public final class MysqlxCrud { + private MysqlxCrud() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + /** + * 
+   **
+   *DataModel to use for filters, names, ...
+   *
+ * + * Protobuf enum {@code Mysqlx.Crud.DataModel} + */ + public enum DataModel + implements com.google.protobuf.ProtocolMessageEnum { + /** + * DOCUMENT = 1; + */ + DOCUMENT(1), + /** + * TABLE = 2; + */ + TABLE(2), + ; + + /** + * DOCUMENT = 1; + */ + public static final int DOCUMENT_VALUE = 1; + /** + * TABLE = 2; + */ + public static final int TABLE_VALUE = 2; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static DataModel valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static DataModel forNumber(int value) { + switch (value) { + case 1: return DOCUMENT; + case 2: return TABLE; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + DataModel> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public DataModel findValueByNumber(int number) { + return DataModel.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.getDescriptor().getEnumTypes().get(0); + } + + private static final DataModel[] VALUES = values(); + + public static DataModel valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private DataModel(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Crud.DataModel) + } + + /** + * 
+   **
+   *ViewAlgorithm defines how MySQL Server processes the view
+   *
+ * + * Protobuf enum {@code Mysqlx.Crud.ViewAlgorithm} + */ + public enum ViewAlgorithm + implements com.google.protobuf.ProtocolMessageEnum { + /** + * 
+     ** MySQL chooses which algorithm to use 
+     *
+ * + * UNDEFINED = 1; + */ + UNDEFINED(1), + /** + * 
+     ** the text of a statement that refers to the view and the view
+     *definition are merged 
+     *
+ * + * MERGE = 2; + */ + MERGE(2), + /** + * 
+     ** the view are retrieved into a temporary table 
+     *
+ * + * TEMPTABLE = 3; + */ + TEMPTABLE(3), + ; + + /** + * 
+     ** MySQL chooses which algorithm to use 
+     *
+ * + * UNDEFINED = 1; + */ + public static final int UNDEFINED_VALUE = 1; + /** + * 
+     ** the text of a statement that refers to the view and the view
+     *definition are merged 
+     *
+ * + * MERGE = 2; + */ + public static final int MERGE_VALUE = 2; + /** + * 
+     ** the view are retrieved into a temporary table 
+     *
+ * + * TEMPTABLE = 3; + */ + public static final int TEMPTABLE_VALUE = 3; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static ViewAlgorithm valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static ViewAlgorithm forNumber(int value) { + switch (value) { + case 1: return UNDEFINED; + case 2: return MERGE; + case 3: return TEMPTABLE; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + ViewAlgorithm> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public ViewAlgorithm findValueByNumber(int number) { + return ViewAlgorithm.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.getDescriptor().getEnumTypes().get(1); + } + + private static final ViewAlgorithm[] VALUES = values(); + + public static ViewAlgorithm valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private ViewAlgorithm(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Crud.ViewAlgorithm) + } + + /** + * 
+   **
+   *ViewSqlSecurity defines the security context in which the view is going to be
+   *executed, this means that VIEW can be executed with current user permissions or
+   *with permissions of the uses who defined the VIEW
+   *
+ * + * Protobuf enum {@code Mysqlx.Crud.ViewSqlSecurity} + */ + public enum ViewSqlSecurity + implements com.google.protobuf.ProtocolMessageEnum { + /** + * 
+     ** use current user permissions 
+     *
+ * + * INVOKER = 1; + */ + INVOKER(1), + /** + * 
+     ** use permissions of the uses who defined the VIEW 
+     *
+ * + * DEFINER = 2; + */ + DEFINER(2), + ; + + /** + * 
+     ** use current user permissions 
+     *
+ * + * INVOKER = 1; + */ + public static final int INVOKER_VALUE = 1; + /** + * 
+     ** use permissions of the uses who defined the VIEW 
+     *
+ * + * DEFINER = 2; + */ + public static final int DEFINER_VALUE = 2; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static ViewSqlSecurity valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static ViewSqlSecurity forNumber(int value) { + switch (value) { + case 1: return INVOKER; + case 2: return DEFINER; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + ViewSqlSecurity> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public ViewSqlSecurity findValueByNumber(int number) { + return ViewSqlSecurity.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.getDescriptor().getEnumTypes().get(2); + } + + private static final ViewSqlSecurity[] VALUES = values(); + + public static ViewSqlSecurity valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private ViewSqlSecurity(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Crud.ViewSqlSecurity) + } + + /** + * 
+   **
+   *ViewCheckOption limits the write operations done on a `VIEW`
+   *(`INSERT`, `UPDATE`, `DELETE`) to rows in which the `WHERE` clause is `TRUE`
+   *
+ * + * Protobuf enum {@code Mysqlx.Crud.ViewCheckOption} + */ + public enum ViewCheckOption + implements com.google.protobuf.ProtocolMessageEnum { + /** + * 
+     ** the view WHERE clause is checked, but no underlying views are checked 
+     *
+ * + * LOCAL = 1; + */ + LOCAL(1), + /** + * 
+     ** the view WHERE clause is checked, then checking recurses
+     *to underlying views 
+     *
+ * + * CASCADED = 2; + */ + CASCADED(2), + ; + + /** + * 
+     ** the view WHERE clause is checked, but no underlying views are checked 
+     *
+ * + * LOCAL = 1; + */ + public static final int LOCAL_VALUE = 1; + /** + * 
+     ** the view WHERE clause is checked, then checking recurses
+     *to underlying views 
+     *
+ * + * CASCADED = 2; + */ + public static final int CASCADED_VALUE = 2; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static ViewCheckOption valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static ViewCheckOption forNumber(int value) { + switch (value) { + case 1: return LOCAL; + case 2: return CASCADED; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + ViewCheckOption> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public ViewCheckOption findValueByNumber(int number) { + return ViewCheckOption.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.getDescriptor().getEnumTypes().get(3); + } + + private static final ViewCheckOption[] VALUES = values(); + + public static ViewCheckOption valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private ViewCheckOption(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Crud.ViewCheckOption) + } + + public interface ColumnOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Crud.Column) + com.google.protobuf.MessageOrBuilder { + + /** + * optional string name = 1; + * @return Whether the name field is set. + */ + boolean hasName(); + /** + * optional string name = 1; + * @return The name. + */ + java.lang.String getName(); + /** + * optional string name = 1; + * @return The bytes for name. + */ + com.google.protobuf.ByteString + getNameBytes(); + + /** + * optional string alias = 2; + * @return Whether the alias field is set. + */ + boolean hasAlias(); + /** + * optional string alias = 2; + * @return The alias. + */ + java.lang.String getAlias(); + /** + * optional string alias = 2; + * @return The bytes for alias. + */ + com.google.protobuf.ByteString + getAliasBytes(); + + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + java.util.List + getDocumentPathList(); + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem getDocumentPath(int index); + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + int getDocumentPathCount(); + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + java.util.List + getDocumentPathOrBuilderList(); + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItemOrBuilder getDocumentPathOrBuilder( + int index); + } + /** + * Protobuf type {@code Mysqlx.Crud.Column} + */ + public static final class Column extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Crud.Column) + ColumnOrBuilder { + private static final long serialVersionUID = 0L; + // Use Column.newBuilder() to construct. + private Column(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Column() { + name_ = ""; + alias_ = ""; + documentPath_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Column(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Column( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000001; + name_ = bs; + break; + } + case 18: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000002; + alias_ = bs; + break; + } + case 26: { + if (!((mutable_bitField0_ & 0x00000004) != 0)) { + documentPath_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000004; + } + documentPath_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.PARSER, extensionRegistry)); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000004) != 0)) { + documentPath_ = java.util.Collections.unmodifiableList(documentPath_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Column_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Column_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.Column.class, com.mysql.cj.x.protobuf.MysqlxCrud.Column.Builder.class); + } + + private int bitField0_; + public static final int NAME_FIELD_NUMBER = 1; + private volatile java.lang.Object name_; + /** + * optional string name = 1; + * @return Whether the name field is set. + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * optional string name = 1; + * @return The name. + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } + } + /** + * optional string name = 1; + * @return The bytes for name. + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int ALIAS_FIELD_NUMBER = 2; + private volatile java.lang.Object alias_; + /** + * optional string alias = 2; + * @return Whether the alias field is set. + */ + public boolean hasAlias() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional string alias = 2; + * @return The alias. + */ + public java.lang.String getAlias() { + java.lang.Object ref = alias_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + alias_ = s; + } + return s; + } + } + /** + * optional string alias = 2; + * @return The bytes for alias. + */ + public com.google.protobuf.ByteString + getAliasBytes() { + java.lang.Object ref = alias_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + alias_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int DOCUMENT_PATH_FIELD_NUMBER = 3; + private java.util.List documentPath_; + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public java.util.List getDocumentPathList() { + return documentPath_; + } + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public java.util.List + getDocumentPathOrBuilderList() { + return documentPath_; + } + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public int getDocumentPathCount() { + return documentPath_.size(); + } + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem getDocumentPath(int index) { + return documentPath_.get(index); + } + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItemOrBuilder getDocumentPathOrBuilder( + int index) { + return documentPath_.get(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + for (int i = 0; i < getDocumentPathCount(); i++) { + if (!getDocumentPath(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, name_); + } + if (((bitField0_ & 0x00000002) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, alias_); + } + for (int i = 0; i < documentPath_.size(); i++) { + output.writeMessage(3, documentPath_.get(i)); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, name_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, alias_); + } + for (int i = 0; i < documentPath_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, documentPath_.get(i)); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxCrud.Column)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxCrud.Column other = (com.mysql.cj.x.protobuf.MysqlxCrud.Column) obj; + + if (hasName() != other.hasName()) return false; + if (hasName()) { + if (!getName() + .equals(other.getName())) return false; + } + if (hasAlias() != other.hasAlias()) return false; + if (hasAlias()) { + if (!getAlias() + .equals(other.getAlias())) return false; + } + if (!getDocumentPathList() + .equals(other.getDocumentPathList())) return false; + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasName()) { + hash = (37 * hash) + NAME_FIELD_NUMBER; + hash = (53 * hash) + getName().hashCode(); + } + if (hasAlias()) { + hash = (37 * hash) + ALIAS_FIELD_NUMBER; + hash = (53 * hash) + getAlias().hashCode(); + } + if (getDocumentPathCount() > 0) { + hash = (37 * hash) + DOCUMENT_PATH_FIELD_NUMBER; + hash = (53 * hash) + getDocumentPathList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.Column parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Column parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Column parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Column parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Column parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Column parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Column parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Column parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Column parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Column parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Column parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Column parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxCrud.Column prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Mysqlx.Crud.Column} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Crud.Column) + com.mysql.cj.x.protobuf.MysqlxCrud.ColumnOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Column_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Column_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.Column.class, com.mysql.cj.x.protobuf.MysqlxCrud.Column.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxCrud.Column.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getDocumentPathFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + name_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + alias_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + if (documentPathBuilder_ == null) { + documentPath_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + } else { + documentPathBuilder_.clear(); + } + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Column_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Column getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.Column.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Column build() { + com.mysql.cj.x.protobuf.MysqlxCrud.Column result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Column buildPartial() { + com.mysql.cj.x.protobuf.MysqlxCrud.Column result = new com.mysql.cj.x.protobuf.MysqlxCrud.Column(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.name_ = name_; + if (((from_bitField0_ & 0x00000002) != 0)) { + to_bitField0_ |= 0x00000002; + } + result.alias_ = alias_; + if (documentPathBuilder_ == null) { + if (((bitField0_ & 0x00000004) != 0)) { + documentPath_ = java.util.Collections.unmodifiableList(documentPath_); + bitField0_ = (bitField0_ & ~0x00000004); + } + result.documentPath_ = documentPath_; + } else { + result.documentPath_ = documentPathBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxCrud.Column) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxCrud.Column)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxCrud.Column other) { + if (other == com.mysql.cj.x.protobuf.MysqlxCrud.Column.getDefaultInstance()) return this; + if (other.hasName()) { + bitField0_ |= 0x00000001; + name_ = other.name_; + onChanged(); + } + if (other.hasAlias()) { + bitField0_ |= 0x00000002; + alias_ = other.alias_; + onChanged(); + } + if (documentPathBuilder_ == null) { + if (!other.documentPath_.isEmpty()) { + if (documentPath_.isEmpty()) { + documentPath_ = other.documentPath_; + bitField0_ = (bitField0_ & ~0x00000004); + } else { + ensureDocumentPathIsMutable(); + documentPath_.addAll(other.documentPath_); + } + onChanged(); + } + } else { + if (!other.documentPath_.isEmpty()) { + if (documentPathBuilder_.isEmpty()) { + documentPathBuilder_.dispose(); + documentPathBuilder_ = null; + documentPath_ = other.documentPath_; + bitField0_ = (bitField0_ & ~0x00000004); + documentPathBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getDocumentPathFieldBuilder() : null; + } else { + documentPathBuilder_.addAllMessages(other.documentPath_); + } + } + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + for (int i = 0; i < getDocumentPathCount(); i++) { + if (!getDocumentPath(i).isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxCrud.Column parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxCrud.Column) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object name_ = ""; + /** + * optional string name = 1; + * @return Whether the name field is set. + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * optional string name = 1; + * @return The name. + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string name = 1; + * @return The bytes for name. + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * optional string name = 1; + * @param value The name to set. + * @return This builder for chaining. + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + name_ = value; + onChanged(); + return this; + } + /** + * optional string name = 1; + * @return This builder for chaining. + */ + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000001); + name_ = getDefaultInstance().getName(); + onChanged(); + return this; + } + /** + * optional string name = 1; + * @param value The bytes for name to set. + * @return This builder for chaining. + */ + public Builder setNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + name_ = value; + onChanged(); + return this; + } + + private java.lang.Object alias_ = ""; + /** + * optional string alias = 2; + * @return Whether the alias field is set. + */ + public boolean hasAlias() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional string alias = 2; + * @return The alias. + */ + public java.lang.String getAlias() { + java.lang.Object ref = alias_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + alias_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string alias = 2; + * @return The bytes for alias. + */ + public com.google.protobuf.ByteString + getAliasBytes() { + java.lang.Object ref = alias_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + alias_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * optional string alias = 2; + * @param value The alias to set. + * @return This builder for chaining. + */ + public Builder setAlias( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + alias_ = value; + onChanged(); + return this; + } + /** + * optional string alias = 2; + * @return This builder for chaining. + */ + public Builder clearAlias() { + bitField0_ = (bitField0_ & ~0x00000002); + alias_ = getDefaultInstance().getAlias(); + onChanged(); + return this; + } + /** + * optional string alias = 2; + * @param value The bytes for alias to set. + * @return This builder for chaining. + */ + public Builder setAliasBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + alias_ = value; + onChanged(); + return this; + } + + private java.util.List documentPath_ = + java.util.Collections.emptyList(); + private void ensureDocumentPathIsMutable() { + if (!((bitField0_ & 0x00000004) != 0)) { + documentPath_ = new java.util.ArrayList(documentPath_); + bitField0_ |= 0x00000004; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItemOrBuilder> documentPathBuilder_; + + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public java.util.List getDocumentPathList() { + if (documentPathBuilder_ == null) { + return java.util.Collections.unmodifiableList(documentPath_); + } else { + return documentPathBuilder_.getMessageList(); + } + } + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public int getDocumentPathCount() { + if (documentPathBuilder_ == null) { + return documentPath_.size(); + } else { + return documentPathBuilder_.getCount(); + } + } + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem getDocumentPath(int index) { + if (documentPathBuilder_ == null) { + return documentPath_.get(index); + } else { + return documentPathBuilder_.getMessage(index); + } + } + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public Builder setDocumentPath( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem value) { + if (documentPathBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureDocumentPathIsMutable(); + documentPath_.set(index, value); + onChanged(); + } else { + documentPathBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public Builder setDocumentPath( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Builder builderForValue) { + if (documentPathBuilder_ == null) { + ensureDocumentPathIsMutable(); + documentPath_.set(index, builderForValue.build()); + onChanged(); + } else { + documentPathBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public Builder addDocumentPath(com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem value) { + if (documentPathBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureDocumentPathIsMutable(); + documentPath_.add(value); + onChanged(); + } else { + documentPathBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public Builder addDocumentPath( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem value) { + if (documentPathBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureDocumentPathIsMutable(); + documentPath_.add(index, value); + onChanged(); + } else { + documentPathBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public Builder addDocumentPath( + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Builder builderForValue) { + if (documentPathBuilder_ == null) { + ensureDocumentPathIsMutable(); + documentPath_.add(builderForValue.build()); + onChanged(); + } else { + documentPathBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public Builder addDocumentPath( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Builder builderForValue) { + if (documentPathBuilder_ == null) { + ensureDocumentPathIsMutable(); + documentPath_.add(index, builderForValue.build()); + onChanged(); + } else { + documentPathBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public Builder addAllDocumentPath( + java.lang.Iterable values) { + if (documentPathBuilder_ == null) { + ensureDocumentPathIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, documentPath_); + onChanged(); + } else { + documentPathBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public Builder clearDocumentPath() { + if (documentPathBuilder_ == null) { + documentPath_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + onChanged(); + } else { + documentPathBuilder_.clear(); + } + return this; + } + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public Builder removeDocumentPath(int index) { + if (documentPathBuilder_ == null) { + ensureDocumentPathIsMutable(); + documentPath_.remove(index); + onChanged(); + } else { + documentPathBuilder_.remove(index); + } + return this; + } + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Builder getDocumentPathBuilder( + int index) { + return getDocumentPathFieldBuilder().getBuilder(index); + } + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItemOrBuilder getDocumentPathOrBuilder( + int index) { + if (documentPathBuilder_ == null) { + return documentPath_.get(index); } else { + return documentPathBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public java.util.List + getDocumentPathOrBuilderList() { + if (documentPathBuilder_ != null) { + return documentPathBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(documentPath_); + } + } + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Builder addDocumentPathBuilder() { + return getDocumentPathFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.getDefaultInstance()); + } + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Builder addDocumentPathBuilder( + int index) { + return getDocumentPathFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.getDefaultInstance()); + } + /** + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 3; + */ + public java.util.List + getDocumentPathBuilderList() { + return getDocumentPathFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItemOrBuilder> + getDocumentPathFieldBuilder() { + if (documentPathBuilder_ == null) { + documentPathBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItemOrBuilder>( + documentPath_, + ((bitField0_ & 0x00000004) != 0), + getParentForChildren(), + isClean()); + documentPath_ = null; + } + return documentPathBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Crud.Column) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Crud.Column) + private static final com.mysql.cj.x.protobuf.MysqlxCrud.Column DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxCrud.Column(); + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.Column getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Column parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Column(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Column getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ProjectionOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Crud.Projection) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** the expression identifying an element from the source data
+     *which can include a column identifier or any expression 
+     *
+ * + * required .Mysqlx.Expr.Expr source = 1; + * @return Whether the source field is set. + */ + boolean hasSource(); + /** + * 
+     ** the expression identifying an element from the source data
+     *which can include a column identifier or any expression 
+     *
+ * + * required .Mysqlx.Expr.Expr source = 1; + * @return The source. + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Expr getSource(); + /** + * 
+     ** the expression identifying an element from the source data
+     *which can include a column identifier or any expression 
+     *
+ * + * required .Mysqlx.Expr.Expr source = 1; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getSourceOrBuilder(); + + /** + * 
+     ** optional alias. Required for DOCUMENTs (clients may use
+     *the source string as default) 
+     *
+ * + * optional string alias = 2; + * @return Whether the alias field is set. + */ + boolean hasAlias(); + /** + * 
+     ** optional alias. Required for DOCUMENTs (clients may use
+     *the source string as default) 
+     *
+ * + * optional string alias = 2; + * @return The alias. + */ + java.lang.String getAlias(); + /** + * 
+     ** optional alias. Required for DOCUMENTs (clients may use
+     *the source string as default) 
+     *
+ * + * optional string alias = 2; + * @return The bytes for alias. + */ + com.google.protobuf.ByteString + getAliasBytes(); + } + /** + * Protobuf type {@code Mysqlx.Crud.Projection} + */ + public static final class Projection extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Crud.Projection) + ProjectionOrBuilder { + private static final long serialVersionUID = 0L; + // Use Projection.newBuilder() to construct. + private Projection(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Projection() { + alias_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Projection(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Projection( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) != 0)) { + subBuilder = source_.toBuilder(); + } + source_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.Expr.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(source_); + source_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000002; + alias_ = bs; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Projection_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Projection_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.Projection.class, com.mysql.cj.x.protobuf.MysqlxCrud.Projection.Builder.class); + } + + private int bitField0_; + public static final int SOURCE_FIELD_NUMBER = 1; + private com.mysql.cj.x.protobuf.MysqlxExpr.Expr source_; + /** + * 
+     ** the expression identifying an element from the source data
+     *which can include a column identifier or any expression 
+     *
+ * + * required .Mysqlx.Expr.Expr source = 1; + * @return Whether the source field is set. + */ + public boolean hasSource() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** the expression identifying an element from the source data
+     *which can include a column identifier or any expression 
+     *
+ * + * required .Mysqlx.Expr.Expr source = 1; + * @return The source. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getSource() { + return source_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : source_; + } + /** + * 
+     ** the expression identifying an element from the source data
+     *which can include a column identifier or any expression 
+     *
+ * + * required .Mysqlx.Expr.Expr source = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getSourceOrBuilder() { + return source_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : source_; + } + + public static final int ALIAS_FIELD_NUMBER = 2; + private volatile java.lang.Object alias_; + /** + * 
+     ** optional alias. Required for DOCUMENTs (clients may use
+     *the source string as default) 
+     *
+ * + * optional string alias = 2; + * @return Whether the alias field is set. + */ + public boolean hasAlias() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** optional alias. Required for DOCUMENTs (clients may use
+     *the source string as default) 
+     *
+ * + * optional string alias = 2; + * @return The alias. + */ + public java.lang.String getAlias() { + java.lang.Object ref = alias_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + alias_ = s; + } + return s; + } + } + /** + * 
+     ** optional alias. Required for DOCUMENTs (clients may use
+     *the source string as default) 
+     *
+ * + * optional string alias = 2; + * @return The bytes for alias. + */ + public com.google.protobuf.ByteString + getAliasBytes() { + java.lang.Object ref = alias_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + alias_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasSource()) { + memoizedIsInitialized = 0; + return false; + } + if (!getSource().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeMessage(1, getSource()); + } + if (((bitField0_ & 0x00000002) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, alias_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, getSource()); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, alias_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxCrud.Projection)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxCrud.Projection other = (com.mysql.cj.x.protobuf.MysqlxCrud.Projection) obj; + + if (hasSource() != other.hasSource()) return false; + if (hasSource()) { + if (!getSource() + .equals(other.getSource())) return false; + } + if (hasAlias() != other.hasAlias()) return false; + if (hasAlias()) { + if (!getAlias() + .equals(other.getAlias())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasSource()) { + hash = (37 * hash) + SOURCE_FIELD_NUMBER; + hash = (53 * hash) + getSource().hashCode(); + } + if (hasAlias()) { + hash = (37 * hash) + ALIAS_FIELD_NUMBER; + hash = (53 * hash) + getAlias().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.Projection parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Projection parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Projection parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Projection parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Projection parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Projection parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Projection parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Projection parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Projection parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Projection parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Projection parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Projection parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxCrud.Projection prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Mysqlx.Crud.Projection} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Crud.Projection) + com.mysql.cj.x.protobuf.MysqlxCrud.ProjectionOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Projection_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Projection_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.Projection.class, com.mysql.cj.x.protobuf.MysqlxCrud.Projection.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxCrud.Projection.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getSourceFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + if (sourceBuilder_ == null) { + source_ = null; + } else { + sourceBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + alias_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Projection_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Projection getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.Projection.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Projection build() { + com.mysql.cj.x.protobuf.MysqlxCrud.Projection result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Projection buildPartial() { + com.mysql.cj.x.protobuf.MysqlxCrud.Projection result = new com.mysql.cj.x.protobuf.MysqlxCrud.Projection(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + if (sourceBuilder_ == null) { + result.source_ = source_; + } else { + result.source_ = sourceBuilder_.build(); + } + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + to_bitField0_ |= 0x00000002; + } + result.alias_ = alias_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxCrud.Projection) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxCrud.Projection)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxCrud.Projection other) { + if (other == com.mysql.cj.x.protobuf.MysqlxCrud.Projection.getDefaultInstance()) return this; + if (other.hasSource()) { + mergeSource(other.getSource()); + } + if (other.hasAlias()) { + bitField0_ |= 0x00000002; + alias_ = other.alias_; + onChanged(); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasSource()) { + return false; + } + if (!getSource().isInitialized()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxCrud.Projection parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxCrud.Projection) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private com.mysql.cj.x.protobuf.MysqlxExpr.Expr source_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> sourceBuilder_; + /** + * 
+       ** the expression identifying an element from the source data
+       *which can include a column identifier or any expression 
+       *
+ * + * required .Mysqlx.Expr.Expr source = 1; + * @return Whether the source field is set. + */ + public boolean hasSource() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** the expression identifying an element from the source data
+       *which can include a column identifier or any expression 
+       *
+ * + * required .Mysqlx.Expr.Expr source = 1; + * @return The source. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getSource() { + if (sourceBuilder_ == null) { + return source_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : source_; + } else { + return sourceBuilder_.getMessage(); + } + } + /** + * 
+       ** the expression identifying an element from the source data
+       *which can include a column identifier or any expression 
+       *
+ * + * required .Mysqlx.Expr.Expr source = 1; + */ + public Builder setSource(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (sourceBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + source_ = value; + onChanged(); + } else { + sourceBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** the expression identifying an element from the source data
+       *which can include a column identifier or any expression 
+       *
+ * + * required .Mysqlx.Expr.Expr source = 1; + */ + public Builder setSource( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (sourceBuilder_ == null) { + source_ = builderForValue.build(); + onChanged(); + } else { + sourceBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** the expression identifying an element from the source data
+       *which can include a column identifier or any expression 
+       *
+ * + * required .Mysqlx.Expr.Expr source = 1; + */ + public Builder mergeSource(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (sourceBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0) && + source_ != null && + source_ != com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance()) { + source_ = + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.newBuilder(source_).mergeFrom(value).buildPartial(); + } else { + source_ = value; + } + onChanged(); + } else { + sourceBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** the expression identifying an element from the source data
+       *which can include a column identifier or any expression 
+       *
+ * + * required .Mysqlx.Expr.Expr source = 1; + */ + public Builder clearSource() { + if (sourceBuilder_ == null) { + source_ = null; + onChanged(); + } else { + sourceBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + /** + * 
+       ** the expression identifying an element from the source data
+       *which can include a column identifier or any expression 
+       *
+ * + * required .Mysqlx.Expr.Expr source = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder getSourceBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getSourceFieldBuilder().getBuilder(); + } + /** + * 
+       ** the expression identifying an element from the source data
+       *which can include a column identifier or any expression 
+       *
+ * + * required .Mysqlx.Expr.Expr source = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getSourceOrBuilder() { + if (sourceBuilder_ != null) { + return sourceBuilder_.getMessageOrBuilder(); + } else { + return source_ == null ? + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : source_; + } + } + /** + * 
+       ** the expression identifying an element from the source data
+       *which can include a column identifier or any expression 
+       *
+ * + * required .Mysqlx.Expr.Expr source = 1; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> + getSourceFieldBuilder() { + if (sourceBuilder_ == null) { + sourceBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder>( + getSource(), + getParentForChildren(), + isClean()); + source_ = null; + } + return sourceBuilder_; + } + + private java.lang.Object alias_ = ""; + /** + * 
+       ** optional alias. Required for DOCUMENTs (clients may use
+       *the source string as default) 
+       *
+ * + * optional string alias = 2; + * @return Whether the alias field is set. + */ + public boolean hasAlias() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** optional alias. Required for DOCUMENTs (clients may use
+       *the source string as default) 
+       *
+ * + * optional string alias = 2; + * @return The alias. + */ + public java.lang.String getAlias() { + java.lang.Object ref = alias_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + alias_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * 
+       ** optional alias. Required for DOCUMENTs (clients may use
+       *the source string as default) 
+       *
+ * + * optional string alias = 2; + * @return The bytes for alias. + */ + public com.google.protobuf.ByteString + getAliasBytes() { + java.lang.Object ref = alias_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + alias_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * 
+       ** optional alias. Required for DOCUMENTs (clients may use
+       *the source string as default) 
+       *
+ * + * optional string alias = 2; + * @param value The alias to set. + * @return This builder for chaining. + */ + public Builder setAlias( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + alias_ = value; + onChanged(); + return this; + } + /** + * 
+       ** optional alias. Required for DOCUMENTs (clients may use
+       *the source string as default) 
+       *
+ * + * optional string alias = 2; + * @return This builder for chaining. + */ + public Builder clearAlias() { + bitField0_ = (bitField0_ & ~0x00000002); + alias_ = getDefaultInstance().getAlias(); + onChanged(); + return this; + } + /** + * 
+       ** optional alias. Required for DOCUMENTs (clients may use
+       *the source string as default) 
+       *
+ * + * optional string alias = 2; + * @param value The bytes for alias to set. + * @return This builder for chaining. + */ + public Builder setAliasBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + alias_ = value; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Crud.Projection) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Crud.Projection) + private static final com.mysql.cj.x.protobuf.MysqlxCrud.Projection DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxCrud.Projection(); + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.Projection getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Projection parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Projection(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Projection getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface CollectionOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Crud.Collection) + com.google.protobuf.MessageOrBuilder { + + /** + * required string name = 1; + * @return Whether the name field is set. + */ + boolean hasName(); + /** + * required string name = 1; + * @return The name. + */ + java.lang.String getName(); + /** + * required string name = 1; + * @return The bytes for name. + */ + com.google.protobuf.ByteString + getNameBytes(); + + /** + * optional string schema = 2; + * @return Whether the schema field is set. + */ + boolean hasSchema(); + /** + * optional string schema = 2; + * @return The schema. + */ + java.lang.String getSchema(); + /** + * optional string schema = 2; + * @return The bytes for schema. + */ + com.google.protobuf.ByteString + getSchemaBytes(); + } + /** + * Protobuf type {@code Mysqlx.Crud.Collection} + */ + public static final class Collection extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Crud.Collection) + CollectionOrBuilder { + private static final long serialVersionUID = 0L; + // Use Collection.newBuilder() to construct. + private Collection(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Collection() { + name_ = ""; + schema_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Collection(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Collection( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000001; + name_ = bs; + break; + } + case 18: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000002; + schema_ = bs; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Collection_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Collection_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.class, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder.class); + } + + private int bitField0_; + public static final int NAME_FIELD_NUMBER = 1; + private volatile java.lang.Object name_; + /** + * required string name = 1; + * @return Whether the name field is set. + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required string name = 1; + * @return The name. + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } + } + /** + * required string name = 1; + * @return The bytes for name. + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int SCHEMA_FIELD_NUMBER = 2; + private volatile java.lang.Object schema_; + /** + * optional string schema = 2; + * @return Whether the schema field is set. + */ + public boolean hasSchema() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional string schema = 2; + * @return The schema. + */ + public java.lang.String getSchema() { + java.lang.Object ref = schema_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + schema_ = s; + } + return s; + } + } + /** + * optional string schema = 2; + * @return The bytes for schema. + */ + public com.google.protobuf.ByteString + getSchemaBytes() { + java.lang.Object ref = schema_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + schema_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasName()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, name_); + } + if (((bitField0_ & 0x00000002) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, schema_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, name_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, schema_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxCrud.Collection)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxCrud.Collection other = (com.mysql.cj.x.protobuf.MysqlxCrud.Collection) obj; + + if (hasName() != other.hasName()) return false; + if (hasName()) { + if (!getName() + .equals(other.getName())) return false; + } + if (hasSchema() != other.hasSchema()) return false; + if (hasSchema()) { + if (!getSchema() + .equals(other.getSchema())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasName()) { + hash = (37 * hash) + NAME_FIELD_NUMBER; + hash = (53 * hash) + getName().hashCode(); + } + if (hasSchema()) { + hash = (37 * hash) + SCHEMA_FIELD_NUMBER; + hash = (53 * hash) + getSchema().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.Collection parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Collection parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Collection parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Collection parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Collection parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Collection parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Collection parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Collection parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Collection parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Collection parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Collection parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Collection parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxCrud.Collection prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Mysqlx.Crud.Collection} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Crud.Collection) + com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Collection_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Collection_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.class, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxCrud.Collection.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + name_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + schema_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Collection_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection build() { + com.mysql.cj.x.protobuf.MysqlxCrud.Collection result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection buildPartial() { + com.mysql.cj.x.protobuf.MysqlxCrud.Collection result = new com.mysql.cj.x.protobuf.MysqlxCrud.Collection(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.name_ = name_; + if (((from_bitField0_ & 0x00000002) != 0)) { + to_bitField0_ |= 0x00000002; + } + result.schema_ = schema_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxCrud.Collection) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxCrud.Collection)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxCrud.Collection other) { + if (other == com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance()) return this; + if (other.hasName()) { + bitField0_ |= 0x00000001; + name_ = other.name_; + onChanged(); + } + if (other.hasSchema()) { + bitField0_ |= 0x00000002; + schema_ = other.schema_; + onChanged(); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasName()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxCrud.Collection parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxCrud.Collection) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object name_ = ""; + /** + * required string name = 1; + * @return Whether the name field is set. + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required string name = 1; + * @return The name. + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string name = 1; + * @return The bytes for name. + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * required string name = 1; + * @param value The name to set. + * @return This builder for chaining. + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + name_ = value; + onChanged(); + return this; + } + /** + * required string name = 1; + * @return This builder for chaining. + */ + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000001); + name_ = getDefaultInstance().getName(); + onChanged(); + return this; + } + /** + * required string name = 1; + * @param value The bytes for name to set. + * @return This builder for chaining. + */ + public Builder setNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + name_ = value; + onChanged(); + return this; + } + + private java.lang.Object schema_ = ""; + /** + * optional string schema = 2; + * @return Whether the schema field is set. + */ + public boolean hasSchema() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional string schema = 2; + * @return The schema. + */ + public java.lang.String getSchema() { + java.lang.Object ref = schema_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + schema_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string schema = 2; + * @return The bytes for schema. + */ + public com.google.protobuf.ByteString + getSchemaBytes() { + java.lang.Object ref = schema_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + schema_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * optional string schema = 2; + * @param value The schema to set. + * @return This builder for chaining. + */ + public Builder setSchema( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + schema_ = value; + onChanged(); + return this; + } + /** + * optional string schema = 2; + * @return This builder for chaining. + */ + public Builder clearSchema() { + bitField0_ = (bitField0_ & ~0x00000002); + schema_ = getDefaultInstance().getSchema(); + onChanged(); + return this; + } + /** + * optional string schema = 2; + * @param value The bytes for schema to set. + * @return This builder for chaining. + */ + public Builder setSchemaBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + schema_ = value; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Crud.Collection) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Crud.Collection) + private static final com.mysql.cj.x.protobuf.MysqlxCrud.Collection DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxCrud.Collection(); + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.Collection getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Collection parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Collection(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface LimitOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Crud.Limit) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** maximum rows to filter 
+     *
+ * + * required uint64 row_count = 1; + * @return Whether the rowCount field is set. + */ + boolean hasRowCount(); + /** + * 
+     ** maximum rows to filter 
+     *
+ * + * required uint64 row_count = 1; + * @return The rowCount. + */ + long getRowCount(); + + /** + * 
+     ** maximum rows to skip before applying the row_count 
+     *
+ * + * optional uint64 offset = 2; + * @return Whether the offset field is set. + */ + boolean hasOffset(); + /** + * 
+     ** maximum rows to skip before applying the row_count 
+     *
+ * + * optional uint64 offset = 2; + * @return The offset. + */ + long getOffset(); + } + /** + * Protobuf type {@code Mysqlx.Crud.Limit} + */ + public static final class Limit extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Crud.Limit) + LimitOrBuilder { + private static final long serialVersionUID = 0L; + // Use Limit.newBuilder() to construct. + private Limit(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Limit() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Limit(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Limit( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + bitField0_ |= 0x00000001; + rowCount_ = input.readUInt64(); + break; + } + case 16: { + bitField0_ |= 0x00000002; + offset_ = input.readUInt64(); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Limit_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Limit_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.Limit.class, com.mysql.cj.x.protobuf.MysqlxCrud.Limit.Builder.class); + } + + private int bitField0_; + public static final int ROW_COUNT_FIELD_NUMBER = 1; + private long rowCount_; + /** + * 
+     ** maximum rows to filter 
+     *
+ * + * required uint64 row_count = 1; + * @return Whether the rowCount field is set. + */ + public boolean hasRowCount() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** maximum rows to filter 
+     *
+ * + * required uint64 row_count = 1; + * @return The rowCount. + */ + public long getRowCount() { + return rowCount_; + } + + public static final int OFFSET_FIELD_NUMBER = 2; + private long offset_; + /** + * 
+     ** maximum rows to skip before applying the row_count 
+     *
+ * + * optional uint64 offset = 2; + * @return Whether the offset field is set. + */ + public boolean hasOffset() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** maximum rows to skip before applying the row_count 
+     *
+ * + * optional uint64 offset = 2; + * @return The offset. + */ + public long getOffset() { + return offset_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasRowCount()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeUInt64(1, rowCount_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeUInt64(2, offset_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt64Size(1, rowCount_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt64Size(2, offset_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxCrud.Limit)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxCrud.Limit other = (com.mysql.cj.x.protobuf.MysqlxCrud.Limit) obj; + + if (hasRowCount() != other.hasRowCount()) return false; + if (hasRowCount()) { + if (getRowCount() + != other.getRowCount()) return false; + } + if (hasOffset() != other.hasOffset()) return false; + if (hasOffset()) { + if (getOffset() + != other.getOffset()) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasRowCount()) { + hash = (37 * hash) + ROW_COUNT_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getRowCount()); + } + if (hasOffset()) { + hash = (37 * hash) + OFFSET_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getOffset()); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.Limit parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Limit parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Limit parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Limit parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Limit parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Limit parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Limit parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Limit parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Limit parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Limit parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Limit parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Limit parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxCrud.Limit prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Mysqlx.Crud.Limit} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Crud.Limit) + com.mysql.cj.x.protobuf.MysqlxCrud.LimitOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Limit_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Limit_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.Limit.class, com.mysql.cj.x.protobuf.MysqlxCrud.Limit.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxCrud.Limit.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + rowCount_ = 0L; + bitField0_ = (bitField0_ & ~0x00000001); + offset_ = 0L; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Limit_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Limit getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.Limit.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Limit build() { + com.mysql.cj.x.protobuf.MysqlxCrud.Limit result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Limit buildPartial() { + com.mysql.cj.x.protobuf.MysqlxCrud.Limit result = new com.mysql.cj.x.protobuf.MysqlxCrud.Limit(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.rowCount_ = rowCount_; + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.offset_ = offset_; + to_bitField0_ |= 0x00000002; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxCrud.Limit) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxCrud.Limit)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxCrud.Limit other) { + if (other == com.mysql.cj.x.protobuf.MysqlxCrud.Limit.getDefaultInstance()) return this; + if (other.hasRowCount()) { + setRowCount(other.getRowCount()); + } + if (other.hasOffset()) { + setOffset(other.getOffset()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasRowCount()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxCrud.Limit parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxCrud.Limit) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private long rowCount_ ; + /** + * 
+       ** maximum rows to filter 
+       *
+ * + * required uint64 row_count = 1; + * @return Whether the rowCount field is set. + */ + public boolean hasRowCount() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** maximum rows to filter 
+       *
+ * + * required uint64 row_count = 1; + * @return The rowCount. + */ + public long getRowCount() { + return rowCount_; + } + /** + * 
+       ** maximum rows to filter 
+       *
+ * + * required uint64 row_count = 1; + * @param value The rowCount to set. + * @return This builder for chaining. + */ + public Builder setRowCount(long value) { + bitField0_ |= 0x00000001; + rowCount_ = value; + onChanged(); + return this; + } + /** + * 
+       ** maximum rows to filter 
+       *
+ * + * required uint64 row_count = 1; + * @return This builder for chaining. + */ + public Builder clearRowCount() { + bitField0_ = (bitField0_ & ~0x00000001); + rowCount_ = 0L; + onChanged(); + return this; + } + + private long offset_ ; + /** + * 
+       ** maximum rows to skip before applying the row_count 
+       *
+ * + * optional uint64 offset = 2; + * @return Whether the offset field is set. + */ + public boolean hasOffset() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** maximum rows to skip before applying the row_count 
+       *
+ * + * optional uint64 offset = 2; + * @return The offset. + */ + public long getOffset() { + return offset_; + } + /** + * 
+       ** maximum rows to skip before applying the row_count 
+       *
+ * + * optional uint64 offset = 2; + * @param value The offset to set. + * @return This builder for chaining. + */ + public Builder setOffset(long value) { + bitField0_ |= 0x00000002; + offset_ = value; + onChanged(); + return this; + } + /** + * 
+       ** maximum rows to skip before applying the row_count 
+       *
+ * + * optional uint64 offset = 2; + * @return This builder for chaining. + */ + public Builder clearOffset() { + bitField0_ = (bitField0_ & ~0x00000002); + offset_ = 0L; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Crud.Limit) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Crud.Limit) + private static final com.mysql.cj.x.protobuf.MysqlxCrud.Limit DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxCrud.Limit(); + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.Limit getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Limit parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Limit(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Limit getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface LimitExprOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Crud.LimitExpr) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** maximum rows to filter 
+     *
+ * + * required .Mysqlx.Expr.Expr row_count = 1; + * @return Whether the rowCount field is set. + */ + boolean hasRowCount(); + /** + * 
+     ** maximum rows to filter 
+     *
+ * + * required .Mysqlx.Expr.Expr row_count = 1; + * @return The rowCount. + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Expr getRowCount(); + /** + * 
+     ** maximum rows to filter 
+     *
+ * + * required .Mysqlx.Expr.Expr row_count = 1; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getRowCountOrBuilder(); + + /** + * 
+     ** maximum rows to skip before applying the row_count 
+     *
+ * + * optional .Mysqlx.Expr.Expr offset = 2; + * @return Whether the offset field is set. + */ + boolean hasOffset(); + /** + * 
+     ** maximum rows to skip before applying the row_count 
+     *
+ * + * optional .Mysqlx.Expr.Expr offset = 2; + * @return The offset. + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Expr getOffset(); + /** + * 
+     ** maximum rows to skip before applying the row_count 
+     *
+ * + * optional .Mysqlx.Expr.Expr offset = 2; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getOffsetOrBuilder(); + } + /** + * 
+   **
+   *LimitExpr in comparison to Limit, is able to specify that row_count and
+   *offset are placeholders.
+   *This message support expressions of following types Expr/literal/UINT,
+   *Expr/PLACEHOLDER.
+   *
+ * + * Protobuf type {@code Mysqlx.Crud.LimitExpr} + */ + public static final class LimitExpr extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Crud.LimitExpr) + LimitExprOrBuilder { + private static final long serialVersionUID = 0L; + // Use LimitExpr.newBuilder() to construct. + private LimitExpr(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private LimitExpr() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new LimitExpr(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private LimitExpr( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) != 0)) { + subBuilder = rowCount_.toBuilder(); + } + rowCount_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.Expr.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(rowCount_); + rowCount_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) != 0)) { + subBuilder = offset_.toBuilder(); + } + offset_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.Expr.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(offset_); + offset_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_LimitExpr_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_LimitExpr_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.class, com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.Builder.class); + } + + private int bitField0_; + public static final int ROW_COUNT_FIELD_NUMBER = 1; + private com.mysql.cj.x.protobuf.MysqlxExpr.Expr rowCount_; + /** + * 
+     ** maximum rows to filter 
+     *
+ * + * required .Mysqlx.Expr.Expr row_count = 1; + * @return Whether the rowCount field is set. + */ + public boolean hasRowCount() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** maximum rows to filter 
+     *
+ * + * required .Mysqlx.Expr.Expr row_count = 1; + * @return The rowCount. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getRowCount() { + return rowCount_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : rowCount_; + } + /** + * 
+     ** maximum rows to filter 
+     *
+ * + * required .Mysqlx.Expr.Expr row_count = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getRowCountOrBuilder() { + return rowCount_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : rowCount_; + } + + public static final int OFFSET_FIELD_NUMBER = 2; + private com.mysql.cj.x.protobuf.MysqlxExpr.Expr offset_; + /** + * 
+     ** maximum rows to skip before applying the row_count 
+     *
+ * + * optional .Mysqlx.Expr.Expr offset = 2; + * @return Whether the offset field is set. + */ + public boolean hasOffset() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** maximum rows to skip before applying the row_count 
+     *
+ * + * optional .Mysqlx.Expr.Expr offset = 2; + * @return The offset. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getOffset() { + return offset_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : offset_; + } + /** + * 
+     ** maximum rows to skip before applying the row_count 
+     *
+ * + * optional .Mysqlx.Expr.Expr offset = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getOffsetOrBuilder() { + return offset_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : offset_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasRowCount()) { + memoizedIsInitialized = 0; + return false; + } + if (!getRowCount().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (hasOffset()) { + if (!getOffset().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeMessage(1, getRowCount()); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeMessage(2, getOffset()); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, getRowCount()); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, getOffset()); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr other = (com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr) obj; + + if (hasRowCount() != other.hasRowCount()) return false; + if (hasRowCount()) { + if (!getRowCount() + .equals(other.getRowCount())) return false; + } + if (hasOffset() != other.hasOffset()) return false; + if (hasOffset()) { + if (!getOffset() + .equals(other.getOffset())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasRowCount()) { + hash = (37 * hash) + ROW_COUNT_FIELD_NUMBER; + hash = (53 * hash) + getRowCount().hashCode(); + } + if (hasOffset()) { + hash = (37 * hash) + OFFSET_FIELD_NUMBER; + hash = (53 * hash) + getOffset().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *LimitExpr in comparison to Limit, is able to specify that row_count and
+     *offset are placeholders.
+     *This message support expressions of following types Expr/literal/UINT,
+     *Expr/PLACEHOLDER.
+     *
+ * + * Protobuf type {@code Mysqlx.Crud.LimitExpr} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Crud.LimitExpr) + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExprOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_LimitExpr_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_LimitExpr_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.class, com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getRowCountFieldBuilder(); + getOffsetFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + if (rowCountBuilder_ == null) { + rowCount_ = null; + } else { + rowCountBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + if (offsetBuilder_ == null) { + offset_ = null; + } else { + offsetBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_LimitExpr_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr build() { + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr buildPartial() { + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr result = new com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + if (rowCountBuilder_ == null) { + result.rowCount_ = rowCount_; + } else { + result.rowCount_ = rowCountBuilder_.build(); + } + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + if (offsetBuilder_ == null) { + result.offset_ = offset_; + } else { + result.offset_ = offsetBuilder_.build(); + } + to_bitField0_ |= 0x00000002; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr other) { + if (other == com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.getDefaultInstance()) return this; + if (other.hasRowCount()) { + mergeRowCount(other.getRowCount()); + } + if (other.hasOffset()) { + mergeOffset(other.getOffset()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasRowCount()) { + return false; + } + if (!getRowCount().isInitialized()) { + return false; + } + if (hasOffset()) { + if (!getOffset().isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private com.mysql.cj.x.protobuf.MysqlxExpr.Expr rowCount_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> rowCountBuilder_; + /** + * 
+       ** maximum rows to filter 
+       *
+ * + * required .Mysqlx.Expr.Expr row_count = 1; + * @return Whether the rowCount field is set. + */ + public boolean hasRowCount() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** maximum rows to filter 
+       *
+ * + * required .Mysqlx.Expr.Expr row_count = 1; + * @return The rowCount. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getRowCount() { + if (rowCountBuilder_ == null) { + return rowCount_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : rowCount_; + } else { + return rowCountBuilder_.getMessage(); + } + } + /** + * 
+       ** maximum rows to filter 
+       *
+ * + * required .Mysqlx.Expr.Expr row_count = 1; + */ + public Builder setRowCount(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (rowCountBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + rowCount_ = value; + onChanged(); + } else { + rowCountBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** maximum rows to filter 
+       *
+ * + * required .Mysqlx.Expr.Expr row_count = 1; + */ + public Builder setRowCount( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (rowCountBuilder_ == null) { + rowCount_ = builderForValue.build(); + onChanged(); + } else { + rowCountBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** maximum rows to filter 
+       *
+ * + * required .Mysqlx.Expr.Expr row_count = 1; + */ + public Builder mergeRowCount(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (rowCountBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0) && + rowCount_ != null && + rowCount_ != com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance()) { + rowCount_ = + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.newBuilder(rowCount_).mergeFrom(value).buildPartial(); + } else { + rowCount_ = value; + } + onChanged(); + } else { + rowCountBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** maximum rows to filter 
+       *
+ * + * required .Mysqlx.Expr.Expr row_count = 1; + */ + public Builder clearRowCount() { + if (rowCountBuilder_ == null) { + rowCount_ = null; + onChanged(); + } else { + rowCountBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + /** + * 
+       ** maximum rows to filter 
+       *
+ * + * required .Mysqlx.Expr.Expr row_count = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder getRowCountBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getRowCountFieldBuilder().getBuilder(); + } + /** + * 
+       ** maximum rows to filter 
+       *
+ * + * required .Mysqlx.Expr.Expr row_count = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getRowCountOrBuilder() { + if (rowCountBuilder_ != null) { + return rowCountBuilder_.getMessageOrBuilder(); + } else { + return rowCount_ == null ? + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : rowCount_; + } + } + /** + * 
+       ** maximum rows to filter 
+       *
+ * + * required .Mysqlx.Expr.Expr row_count = 1; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> + getRowCountFieldBuilder() { + if (rowCountBuilder_ == null) { + rowCountBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder>( + getRowCount(), + getParentForChildren(), + isClean()); + rowCount_ = null; + } + return rowCountBuilder_; + } + + private com.mysql.cj.x.protobuf.MysqlxExpr.Expr offset_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> offsetBuilder_; + /** + * 
+       ** maximum rows to skip before applying the row_count 
+       *
+ * + * optional .Mysqlx.Expr.Expr offset = 2; + * @return Whether the offset field is set. + */ + public boolean hasOffset() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** maximum rows to skip before applying the row_count 
+       *
+ * + * optional .Mysqlx.Expr.Expr offset = 2; + * @return The offset. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getOffset() { + if (offsetBuilder_ == null) { + return offset_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : offset_; + } else { + return offsetBuilder_.getMessage(); + } + } + /** + * 
+       ** maximum rows to skip before applying the row_count 
+       *
+ * + * optional .Mysqlx.Expr.Expr offset = 2; + */ + public Builder setOffset(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (offsetBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + offset_ = value; + onChanged(); + } else { + offsetBuilder_.setMessage(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * 
+       ** maximum rows to skip before applying the row_count 
+       *
+ * + * optional .Mysqlx.Expr.Expr offset = 2; + */ + public Builder setOffset( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (offsetBuilder_ == null) { + offset_ = builderForValue.build(); + onChanged(); + } else { + offsetBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * 
+       ** maximum rows to skip before applying the row_count 
+       *
+ * + * optional .Mysqlx.Expr.Expr offset = 2; + */ + public Builder mergeOffset(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (offsetBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0) && + offset_ != null && + offset_ != com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance()) { + offset_ = + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.newBuilder(offset_).mergeFrom(value).buildPartial(); + } else { + offset_ = value; + } + onChanged(); + } else { + offsetBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * 
+       ** maximum rows to skip before applying the row_count 
+       *
+ * + * optional .Mysqlx.Expr.Expr offset = 2; + */ + public Builder clearOffset() { + if (offsetBuilder_ == null) { + offset_ = null; + onChanged(); + } else { + offsetBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + /** + * 
+       ** maximum rows to skip before applying the row_count 
+       *
+ * + * optional .Mysqlx.Expr.Expr offset = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder getOffsetBuilder() { + bitField0_ |= 0x00000002; + onChanged(); + return getOffsetFieldBuilder().getBuilder(); + } + /** + * 
+       ** maximum rows to skip before applying the row_count 
+       *
+ * + * optional .Mysqlx.Expr.Expr offset = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getOffsetOrBuilder() { + if (offsetBuilder_ != null) { + return offsetBuilder_.getMessageOrBuilder(); + } else { + return offset_ == null ? + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : offset_; + } + } + /** + * 
+       ** maximum rows to skip before applying the row_count 
+       *
+ * + * optional .Mysqlx.Expr.Expr offset = 2; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> + getOffsetFieldBuilder() { + if (offsetBuilder_ == null) { + offsetBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder>( + getOffset(), + getParentForChildren(), + isClean()); + offset_ = null; + } + return offsetBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Crud.LimitExpr) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Crud.LimitExpr) + private static final com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr(); + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public LimitExpr parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new LimitExpr(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface OrderOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Crud.Order) + com.google.protobuf.MessageOrBuilder { + + /** + * required .Mysqlx.Expr.Expr expr = 1; + * @return Whether the expr field is set. + */ + boolean hasExpr(); + /** + * required .Mysqlx.Expr.Expr expr = 1; + * @return The expr. + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Expr getExpr(); + /** + * required .Mysqlx.Expr.Expr expr = 1; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getExprOrBuilder(); + + /** + * optional .Mysqlx.Crud.Order.Direction direction = 2 [default = ASC]; + * @return Whether the direction field is set. + */ + boolean hasDirection(); + /** + * optional .Mysqlx.Crud.Order.Direction direction = 2 [default = ASC]; + * @return The direction. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Order.Direction getDirection(); + } + /** + * 
+   **
+   *Sort order
+   *
+ * + * Protobuf type {@code Mysqlx.Crud.Order} + */ + public static final class Order extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Crud.Order) + OrderOrBuilder { + private static final long serialVersionUID = 0L; + // Use Order.newBuilder() to construct. + private Order(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Order() { + direction_ = 1; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Order(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Order( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) != 0)) { + subBuilder = expr_.toBuilder(); + } + expr_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.Expr.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(expr_); + expr_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 16: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.Order.Direction value = com.mysql.cj.x.protobuf.MysqlxCrud.Order.Direction.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(2, rawValue); + } else { + bitField0_ |= 0x00000002; + direction_ = rawValue; + } + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Order_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Order_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.Order.class, com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder.class); + } + + /** + * Protobuf enum {@code Mysqlx.Crud.Order.Direction} + */ + public enum Direction + implements com.google.protobuf.ProtocolMessageEnum { + /** + * ASC = 1; + */ + ASC(1), + /** + * DESC = 2; + */ + DESC(2), + ; + + /** + * ASC = 1; + */ + public static final int ASC_VALUE = 1; + /** + * DESC = 2; + */ + public static final int DESC_VALUE = 2; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static Direction valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static Direction forNumber(int value) { + switch (value) { + case 1: return ASC; + case 2: return DESC; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + Direction> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Direction findValueByNumber(int number) { + return Direction.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.Order.getDescriptor().getEnumTypes().get(0); + } + + private static final Direction[] VALUES = values(); + + public static Direction valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private Direction(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Crud.Order.Direction) + } + + private int bitField0_; + public static final int EXPR_FIELD_NUMBER = 1; + private com.mysql.cj.x.protobuf.MysqlxExpr.Expr expr_; + /** + * required .Mysqlx.Expr.Expr expr = 1; + * @return Whether the expr field is set. + */ + public boolean hasExpr() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required .Mysqlx.Expr.Expr expr = 1; + * @return The expr. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getExpr() { + return expr_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : expr_; + } + /** + * required .Mysqlx.Expr.Expr expr = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getExprOrBuilder() { + return expr_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : expr_; + } + + public static final int DIRECTION_FIELD_NUMBER = 2; + private int direction_; + /** + * optional .Mysqlx.Crud.Order.Direction direction = 2 [default = ASC]; + * @return Whether the direction field is set. + */ + public boolean hasDirection() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional .Mysqlx.Crud.Order.Direction direction = 2 [default = ASC]; + * @return The direction. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Order.Direction getDirection() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.Order.Direction result = com.mysql.cj.x.protobuf.MysqlxCrud.Order.Direction.valueOf(direction_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Order.Direction.ASC : result; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasExpr()) { + memoizedIsInitialized = 0; + return false; + } + if (!getExpr().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeMessage(1, getExpr()); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeEnum(2, direction_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, getExpr()); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(2, direction_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxCrud.Order)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxCrud.Order other = (com.mysql.cj.x.protobuf.MysqlxCrud.Order) obj; + + if (hasExpr() != other.hasExpr()) return false; + if (hasExpr()) { + if (!getExpr() + .equals(other.getExpr())) return false; + } + if (hasDirection() != other.hasDirection()) return false; + if (hasDirection()) { + if (direction_ != other.direction_) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasExpr()) { + hash = (37 * hash) + EXPR_FIELD_NUMBER; + hash = (53 * hash) + getExpr().hashCode(); + } + if (hasDirection()) { + hash = (37 * hash) + DIRECTION_FIELD_NUMBER; + hash = (53 * hash) + direction_; + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.Order parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Order parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Order parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Order parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Order parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Order parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Order parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Order parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Order parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Order parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Order parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Order parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxCrud.Order prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Sort order
+     *
+ * + * Protobuf type {@code Mysqlx.Crud.Order} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Crud.Order) + com.mysql.cj.x.protobuf.MysqlxCrud.OrderOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Order_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Order_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.Order.class, com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxCrud.Order.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getExprFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + if (exprBuilder_ == null) { + expr_ = null; + } else { + exprBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + direction_ = 1; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Order_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Order getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.Order.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Order build() { + com.mysql.cj.x.protobuf.MysqlxCrud.Order result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Order buildPartial() { + com.mysql.cj.x.protobuf.MysqlxCrud.Order result = new com.mysql.cj.x.protobuf.MysqlxCrud.Order(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + if (exprBuilder_ == null) { + result.expr_ = expr_; + } else { + result.expr_ = exprBuilder_.build(); + } + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + to_bitField0_ |= 0x00000002; + } + result.direction_ = direction_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxCrud.Order) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxCrud.Order)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxCrud.Order other) { + if (other == com.mysql.cj.x.protobuf.MysqlxCrud.Order.getDefaultInstance()) return this; + if (other.hasExpr()) { + mergeExpr(other.getExpr()); + } + if (other.hasDirection()) { + setDirection(other.getDirection()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasExpr()) { + return false; + } + if (!getExpr().isInitialized()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxCrud.Order parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxCrud.Order) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private com.mysql.cj.x.protobuf.MysqlxExpr.Expr expr_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> exprBuilder_; + /** + * required .Mysqlx.Expr.Expr expr = 1; + * @return Whether the expr field is set. + */ + public boolean hasExpr() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required .Mysqlx.Expr.Expr expr = 1; + * @return The expr. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getExpr() { + if (exprBuilder_ == null) { + return expr_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : expr_; + } else { + return exprBuilder_.getMessage(); + } + } + /** + * required .Mysqlx.Expr.Expr expr = 1; + */ + public Builder setExpr(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (exprBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + expr_ = value; + onChanged(); + } else { + exprBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * required .Mysqlx.Expr.Expr expr = 1; + */ + public Builder setExpr( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (exprBuilder_ == null) { + expr_ = builderForValue.build(); + onChanged(); + } else { + exprBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * required .Mysqlx.Expr.Expr expr = 1; + */ + public Builder mergeExpr(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (exprBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0) && + expr_ != null && + expr_ != com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance()) { + expr_ = + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.newBuilder(expr_).mergeFrom(value).buildPartial(); + } else { + expr_ = value; + } + onChanged(); + } else { + exprBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * required .Mysqlx.Expr.Expr expr = 1; + */ + public Builder clearExpr() { + if (exprBuilder_ == null) { + expr_ = null; + onChanged(); + } else { + exprBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + /** + * required .Mysqlx.Expr.Expr expr = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder getExprBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getExprFieldBuilder().getBuilder(); + } + /** + * required .Mysqlx.Expr.Expr expr = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getExprOrBuilder() { + if (exprBuilder_ != null) { + return exprBuilder_.getMessageOrBuilder(); + } else { + return expr_ == null ? + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : expr_; + } + } + /** + * required .Mysqlx.Expr.Expr expr = 1; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> + getExprFieldBuilder() { + if (exprBuilder_ == null) { + exprBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder>( + getExpr(), + getParentForChildren(), + isClean()); + expr_ = null; + } + return exprBuilder_; + } + + private int direction_ = 1; + /** + * optional .Mysqlx.Crud.Order.Direction direction = 2 [default = ASC]; + * @return Whether the direction field is set. + */ + public boolean hasDirection() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional .Mysqlx.Crud.Order.Direction direction = 2 [default = ASC]; + * @return The direction. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Order.Direction getDirection() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.Order.Direction result = com.mysql.cj.x.protobuf.MysqlxCrud.Order.Direction.valueOf(direction_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Order.Direction.ASC : result; + } + /** + * optional .Mysqlx.Crud.Order.Direction direction = 2 [default = ASC]; + * @param value The direction to set. + * @return This builder for chaining. + */ + public Builder setDirection(com.mysql.cj.x.protobuf.MysqlxCrud.Order.Direction value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + direction_ = value.getNumber(); + onChanged(); + return this; + } + /** + * optional .Mysqlx.Crud.Order.Direction direction = 2 [default = ASC]; + * @return This builder for chaining. + */ + public Builder clearDirection() { + bitField0_ = (bitField0_ & ~0x00000002); + direction_ = 1; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Crud.Order) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Crud.Order) + private static final com.mysql.cj.x.protobuf.MysqlxCrud.Order DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxCrud.Order(); + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.Order getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Order parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Order(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Order getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface UpdateOperationOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Crud.UpdateOperation) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** specification of the value to be updated
+     *- if data_model is TABLE, a column name may be specified and also
+     *a document path, if the column has type JSON
+     *- if data_model is DOCUMENT, only document paths are allowed
+     *@note in both cases, schema and table must be not set 
+     *
+ * + * required .Mysqlx.Expr.ColumnIdentifier source = 1; + * @return Whether the source field is set. + */ + boolean hasSource(); + /** + * 
+     ** specification of the value to be updated
+     *- if data_model is TABLE, a column name may be specified and also
+     *a document path, if the column has type JSON
+     *- if data_model is DOCUMENT, only document paths are allowed
+     *@note in both cases, schema and table must be not set 
+     *
+ * + * required .Mysqlx.Expr.ColumnIdentifier source = 1; + * @return The source. + */ + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier getSource(); + /** + * 
+     ** specification of the value to be updated
+     *- if data_model is TABLE, a column name may be specified and also
+     *a document path, if the column has type JSON
+     *- if data_model is DOCUMENT, only document paths are allowed
+     *@note in both cases, schema and table must be not set 
+     *
+ * + * required .Mysqlx.Expr.ColumnIdentifier source = 1; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifierOrBuilder getSourceOrBuilder(); + + /** + * 
+     ** the type of operation to be performed 
+     *
+ * + * required .Mysqlx.Crud.UpdateOperation.UpdateType operation = 2; + * @return Whether the operation field is set. + */ + boolean hasOperation(); + /** + * 
+     ** the type of operation to be performed 
+     *
+ * + * required .Mysqlx.Crud.UpdateOperation.UpdateType operation = 2; + * @return The operation. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.UpdateType getOperation(); + + /** + * 
+     ** an expression to be computed as the new value for the operation 
+     *
+ * + * optional .Mysqlx.Expr.Expr value = 3; + * @return Whether the value field is set. + */ + boolean hasValue(); + /** + * 
+     ** an expression to be computed as the new value for the operation 
+     *
+ * + * optional .Mysqlx.Expr.Expr value = 3; + * @return The value. + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Expr getValue(); + /** + * 
+     ** an expression to be computed as the new value for the operation 
+     *
+ * + * optional .Mysqlx.Expr.Expr value = 3; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getValueOrBuilder(); + } + /** + * Protobuf type {@code Mysqlx.Crud.UpdateOperation} + */ + public static final class UpdateOperation extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Crud.UpdateOperation) + UpdateOperationOrBuilder { + private static final long serialVersionUID = 0L; + // Use UpdateOperation.newBuilder() to construct. + private UpdateOperation(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private UpdateOperation() { + operation_ = 1; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new UpdateOperation(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private UpdateOperation( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) != 0)) { + subBuilder = source_.toBuilder(); + } + source_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(source_); + source_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 16: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.UpdateType value = com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.UpdateType.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(2, rawValue); + } else { + bitField0_ |= 0x00000002; + operation_ = rawValue; + } + break; + } + case 26: { + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) != 0)) { + subBuilder = value_.toBuilder(); + } + value_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.Expr.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(value_); + value_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_UpdateOperation_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_UpdateOperation_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.class, com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.Builder.class); + } + + /** + * Protobuf enum {@code Mysqlx.Crud.UpdateOperation.UpdateType} + */ + public enum UpdateType + implements com.google.protobuf.ProtocolMessageEnum { + /** + * 
+       ** only allowed for TABLE 
+       *
+ * + * SET = 1; + */ + SET(1), + /** + * 
+       ** no value (removes the identified path from a object or array) 
+       *
+ * + * ITEM_REMOVE = 2; + */ + ITEM_REMOVE(2), + /** + * 
+       ** sets the new value on the identified path 
+       *
+ * + * ITEM_SET = 3; + */ + ITEM_SET(3), + /** + * 
+       ** replaces a value if the path exists 
+       *
+ * + * ITEM_REPLACE = 4; + */ + ITEM_REPLACE(4), + /** + * 
+       ** source and value must be documents 
+       *
+ * + * ITEM_MERGE = 5; + */ + ITEM_MERGE(5), + /** + * 
+       ** insert the value in the array at the index identified in the source path 
+       *
+ * + * ARRAY_INSERT = 6; + */ + ARRAY_INSERT(6), + /** + * 
+       ** append the value on the array at the identified path 
+       *
+ * + * ARRAY_APPEND = 7; + */ + ARRAY_APPEND(7), + /** + * 
+       ** merge JSON object value with the provided patch expression 
+       *
+ * + * MERGE_PATCH = 8; + */ + MERGE_PATCH(8), + ; + + /** + * 
+       ** only allowed for TABLE 
+       *
+ * + * SET = 1; + */ + public static final int SET_VALUE = 1; + /** + * 
+       ** no value (removes the identified path from a object or array) 
+       *
+ * + * ITEM_REMOVE = 2; + */ + public static final int ITEM_REMOVE_VALUE = 2; + /** + * 
+       ** sets the new value on the identified path 
+       *
+ * + * ITEM_SET = 3; + */ + public static final int ITEM_SET_VALUE = 3; + /** + * 
+       ** replaces a value if the path exists 
+       *
+ * + * ITEM_REPLACE = 4; + */ + public static final int ITEM_REPLACE_VALUE = 4; + /** + * 
+       ** source and value must be documents 
+       *
+ * + * ITEM_MERGE = 5; + */ + public static final int ITEM_MERGE_VALUE = 5; + /** + * 
+       ** insert the value in the array at the index identified in the source path 
+       *
+ * + * ARRAY_INSERT = 6; + */ + public static final int ARRAY_INSERT_VALUE = 6; + /** + * 
+       ** append the value on the array at the identified path 
+       *
+ * + * ARRAY_APPEND = 7; + */ + public static final int ARRAY_APPEND_VALUE = 7; + /** + * 
+       ** merge JSON object value with the provided patch expression 
+       *
+ * + * MERGE_PATCH = 8; + */ + public static final int MERGE_PATCH_VALUE = 8; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static UpdateType valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static UpdateType forNumber(int value) { + switch (value) { + case 1: return SET; + case 2: return ITEM_REMOVE; + case 3: return ITEM_SET; + case 4: return ITEM_REPLACE; + case 5: return ITEM_MERGE; + case 6: return ARRAY_INSERT; + case 7: return ARRAY_APPEND; + case 8: return MERGE_PATCH; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + UpdateType> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public UpdateType findValueByNumber(int number) { + return UpdateType.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.getDescriptor().getEnumTypes().get(0); + } + + private static final UpdateType[] VALUES = values(); + + public static UpdateType valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private UpdateType(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Crud.UpdateOperation.UpdateType) + } + + private int bitField0_; + public static final int SOURCE_FIELD_NUMBER = 1; + private com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier source_; + /** + * 
+     ** specification of the value to be updated
+     *- if data_model is TABLE, a column name may be specified and also
+     *a document path, if the column has type JSON
+     *- if data_model is DOCUMENT, only document paths are allowed
+     *@note in both cases, schema and table must be not set 
+     *
+ * + * required .Mysqlx.Expr.ColumnIdentifier source = 1; + * @return Whether the source field is set. + */ + public boolean hasSource() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** specification of the value to be updated
+     *- if data_model is TABLE, a column name may be specified and also
+     *a document path, if the column has type JSON
+     *- if data_model is DOCUMENT, only document paths are allowed
+     *@note in both cases, schema and table must be not set 
+     *
+ * + * required .Mysqlx.Expr.ColumnIdentifier source = 1; + * @return The source. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier getSource() { + return source_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.getDefaultInstance() : source_; + } + /** + * 
+     ** specification of the value to be updated
+     *- if data_model is TABLE, a column name may be specified and also
+     *a document path, if the column has type JSON
+     *- if data_model is DOCUMENT, only document paths are allowed
+     *@note in both cases, schema and table must be not set 
+     *
+ * + * required .Mysqlx.Expr.ColumnIdentifier source = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifierOrBuilder getSourceOrBuilder() { + return source_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.getDefaultInstance() : source_; + } + + public static final int OPERATION_FIELD_NUMBER = 2; + private int operation_; + /** + * 
+     ** the type of operation to be performed 
+     *
+ * + * required .Mysqlx.Crud.UpdateOperation.UpdateType operation = 2; + * @return Whether the operation field is set. + */ + public boolean hasOperation() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** the type of operation to be performed 
+     *
+ * + * required .Mysqlx.Crud.UpdateOperation.UpdateType operation = 2; + * @return The operation. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.UpdateType getOperation() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.UpdateType result = com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.UpdateType.valueOf(operation_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.UpdateType.SET : result; + } + + public static final int VALUE_FIELD_NUMBER = 3; + private com.mysql.cj.x.protobuf.MysqlxExpr.Expr value_; + /** + * 
+     ** an expression to be computed as the new value for the operation 
+     *
+ * + * optional .Mysqlx.Expr.Expr value = 3; + * @return Whether the value field is set. + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+     ** an expression to be computed as the new value for the operation 
+     *
+ * + * optional .Mysqlx.Expr.Expr value = 3; + * @return The value. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getValue() { + return value_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : value_; + } + /** + * 
+     ** an expression to be computed as the new value for the operation 
+     *
+ * + * optional .Mysqlx.Expr.Expr value = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getValueOrBuilder() { + return value_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : value_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasSource()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasOperation()) { + memoizedIsInitialized = 0; + return false; + } + if (!getSource().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (hasValue()) { + if (!getValue().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeMessage(1, getSource()); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeEnum(2, operation_); + } + if (((bitField0_ & 0x00000004) != 0)) { + output.writeMessage(3, getValue()); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, getSource()); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(2, operation_); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, getValue()); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation other = (com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation) obj; + + if (hasSource() != other.hasSource()) return false; + if (hasSource()) { + if (!getSource() + .equals(other.getSource())) return false; + } + if (hasOperation() != other.hasOperation()) return false; + if (hasOperation()) { + if (operation_ != other.operation_) return false; + } + if (hasValue() != other.hasValue()) return false; + if (hasValue()) { + if (!getValue() + .equals(other.getValue())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasSource()) { + hash = (37 * hash) + SOURCE_FIELD_NUMBER; + hash = (53 * hash) + getSource().hashCode(); + } + if (hasOperation()) { + hash = (37 * hash) + OPERATION_FIELD_NUMBER; + hash = (53 * hash) + operation_; + } + if (hasValue()) { + hash = (37 * hash) + VALUE_FIELD_NUMBER; + hash = (53 * hash) + getValue().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Mysqlx.Crud.UpdateOperation} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Crud.UpdateOperation) + com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperationOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_UpdateOperation_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_UpdateOperation_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.class, com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getSourceFieldBuilder(); + getValueFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + if (sourceBuilder_ == null) { + source_ = null; + } else { + sourceBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + operation_ = 1; + bitField0_ = (bitField0_ & ~0x00000002); + if (valueBuilder_ == null) { + value_ = null; + } else { + valueBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_UpdateOperation_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation build() { + com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation buildPartial() { + com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation result = new com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + if (sourceBuilder_ == null) { + result.source_ = source_; + } else { + result.source_ = sourceBuilder_.build(); + } + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + to_bitField0_ |= 0x00000002; + } + result.operation_ = operation_; + if (((from_bitField0_ & 0x00000004) != 0)) { + if (valueBuilder_ == null) { + result.value_ = value_; + } else { + result.value_ = valueBuilder_.build(); + } + to_bitField0_ |= 0x00000004; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation other) { + if (other == com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.getDefaultInstance()) return this; + if (other.hasSource()) { + mergeSource(other.getSource()); + } + if (other.hasOperation()) { + setOperation(other.getOperation()); + } + if (other.hasValue()) { + mergeValue(other.getValue()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasSource()) { + return false; + } + if (!hasOperation()) { + return false; + } + if (!getSource().isInitialized()) { + return false; + } + if (hasValue()) { + if (!getValue().isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier source_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier, com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifierOrBuilder> sourceBuilder_; + /** + * 
+       ** specification of the value to be updated
+       *- if data_model is TABLE, a column name may be specified and also
+       *a document path, if the column has type JSON
+       *- if data_model is DOCUMENT, only document paths are allowed
+       *@note in both cases, schema and table must be not set 
+       *
+ * + * required .Mysqlx.Expr.ColumnIdentifier source = 1; + * @return Whether the source field is set. + */ + public boolean hasSource() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** specification of the value to be updated
+       *- if data_model is TABLE, a column name may be specified and also
+       *a document path, if the column has type JSON
+       *- if data_model is DOCUMENT, only document paths are allowed
+       *@note in both cases, schema and table must be not set 
+       *
+ * + * required .Mysqlx.Expr.ColumnIdentifier source = 1; + * @return The source. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier getSource() { + if (sourceBuilder_ == null) { + return source_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.getDefaultInstance() : source_; + } else { + return sourceBuilder_.getMessage(); + } + } + /** + * 
+       ** specification of the value to be updated
+       *- if data_model is TABLE, a column name may be specified and also
+       *a document path, if the column has type JSON
+       *- if data_model is DOCUMENT, only document paths are allowed
+       *@note in both cases, schema and table must be not set 
+       *
+ * + * required .Mysqlx.Expr.ColumnIdentifier source = 1; + */ + public Builder setSource(com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier value) { + if (sourceBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + source_ = value; + onChanged(); + } else { + sourceBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** specification of the value to be updated
+       *- if data_model is TABLE, a column name may be specified and also
+       *a document path, if the column has type JSON
+       *- if data_model is DOCUMENT, only document paths are allowed
+       *@note in both cases, schema and table must be not set 
+       *
+ * + * required .Mysqlx.Expr.ColumnIdentifier source = 1; + */ + public Builder setSource( + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.Builder builderForValue) { + if (sourceBuilder_ == null) { + source_ = builderForValue.build(); + onChanged(); + } else { + sourceBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** specification of the value to be updated
+       *- if data_model is TABLE, a column name may be specified and also
+       *a document path, if the column has type JSON
+       *- if data_model is DOCUMENT, only document paths are allowed
+       *@note in both cases, schema and table must be not set 
+       *
+ * + * required .Mysqlx.Expr.ColumnIdentifier source = 1; + */ + public Builder mergeSource(com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier value) { + if (sourceBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0) && + source_ != null && + source_ != com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.getDefaultInstance()) { + source_ = + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.newBuilder(source_).mergeFrom(value).buildPartial(); + } else { + source_ = value; + } + onChanged(); + } else { + sourceBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** specification of the value to be updated
+       *- if data_model is TABLE, a column name may be specified and also
+       *a document path, if the column has type JSON
+       *- if data_model is DOCUMENT, only document paths are allowed
+       *@note in both cases, schema and table must be not set 
+       *
+ * + * required .Mysqlx.Expr.ColumnIdentifier source = 1; + */ + public Builder clearSource() { + if (sourceBuilder_ == null) { + source_ = null; + onChanged(); + } else { + sourceBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + /** + * 
+       ** specification of the value to be updated
+       *- if data_model is TABLE, a column name may be specified and also
+       *a document path, if the column has type JSON
+       *- if data_model is DOCUMENT, only document paths are allowed
+       *@note in both cases, schema and table must be not set 
+       *
+ * + * required .Mysqlx.Expr.ColumnIdentifier source = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.Builder getSourceBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getSourceFieldBuilder().getBuilder(); + } + /** + * 
+       ** specification of the value to be updated
+       *- if data_model is TABLE, a column name may be specified and also
+       *a document path, if the column has type JSON
+       *- if data_model is DOCUMENT, only document paths are allowed
+       *@note in both cases, schema and table must be not set 
+       *
+ * + * required .Mysqlx.Expr.ColumnIdentifier source = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifierOrBuilder getSourceOrBuilder() { + if (sourceBuilder_ != null) { + return sourceBuilder_.getMessageOrBuilder(); + } else { + return source_ == null ? + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.getDefaultInstance() : source_; + } + } + /** + * 
+       ** specification of the value to be updated
+       *- if data_model is TABLE, a column name may be specified and also
+       *a document path, if the column has type JSON
+       *- if data_model is DOCUMENT, only document paths are allowed
+       *@note in both cases, schema and table must be not set 
+       *
+ * + * required .Mysqlx.Expr.ColumnIdentifier source = 1; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier, com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifierOrBuilder> + getSourceFieldBuilder() { + if (sourceBuilder_ == null) { + sourceBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier, com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifierOrBuilder>( + getSource(), + getParentForChildren(), + isClean()); + source_ = null; + } + return sourceBuilder_; + } + + private int operation_ = 1; + /** + * 
+       ** the type of operation to be performed 
+       *
+ * + * required .Mysqlx.Crud.UpdateOperation.UpdateType operation = 2; + * @return Whether the operation field is set. + */ + public boolean hasOperation() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** the type of operation to be performed 
+       *
+ * + * required .Mysqlx.Crud.UpdateOperation.UpdateType operation = 2; + * @return The operation. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.UpdateType getOperation() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.UpdateType result = com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.UpdateType.valueOf(operation_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.UpdateType.SET : result; + } + /** + * 
+       ** the type of operation to be performed 
+       *
+ * + * required .Mysqlx.Crud.UpdateOperation.UpdateType operation = 2; + * @param value The operation to set. + * @return This builder for chaining. + */ + public Builder setOperation(com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.UpdateType value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + operation_ = value.getNumber(); + onChanged(); + return this; + } + /** + * 
+       ** the type of operation to be performed 
+       *
+ * + * required .Mysqlx.Crud.UpdateOperation.UpdateType operation = 2; + * @return This builder for chaining. + */ + public Builder clearOperation() { + bitField0_ = (bitField0_ & ~0x00000002); + operation_ = 1; + onChanged(); + return this; + } + + private com.mysql.cj.x.protobuf.MysqlxExpr.Expr value_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> valueBuilder_; + /** + * 
+       ** an expression to be computed as the new value for the operation 
+       *
+ * + * optional .Mysqlx.Expr.Expr value = 3; + * @return Whether the value field is set. + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+       ** an expression to be computed as the new value for the operation 
+       *
+ * + * optional .Mysqlx.Expr.Expr value = 3; + * @return The value. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getValue() { + if (valueBuilder_ == null) { + return value_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : value_; + } else { + return valueBuilder_.getMessage(); + } + } + /** + * 
+       ** an expression to be computed as the new value for the operation 
+       *
+ * + * optional .Mysqlx.Expr.Expr value = 3; + */ + public Builder setValue(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (valueBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + value_ = value; + onChanged(); + } else { + valueBuilder_.setMessage(value); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * 
+       ** an expression to be computed as the new value for the operation 
+       *
+ * + * optional .Mysqlx.Expr.Expr value = 3; + */ + public Builder setValue( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (valueBuilder_ == null) { + value_ = builderForValue.build(); + onChanged(); + } else { + valueBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * 
+       ** an expression to be computed as the new value for the operation 
+       *
+ * + * optional .Mysqlx.Expr.Expr value = 3; + */ + public Builder mergeValue(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (valueBuilder_ == null) { + if (((bitField0_ & 0x00000004) != 0) && + value_ != null && + value_ != com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance()) { + value_ = + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.newBuilder(value_).mergeFrom(value).buildPartial(); + } else { + value_ = value; + } + onChanged(); + } else { + valueBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * 
+       ** an expression to be computed as the new value for the operation 
+       *
+ * + * optional .Mysqlx.Expr.Expr value = 3; + */ + public Builder clearValue() { + if (valueBuilder_ == null) { + value_ = null; + onChanged(); + } else { + valueBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + /** + * 
+       ** an expression to be computed as the new value for the operation 
+       *
+ * + * optional .Mysqlx.Expr.Expr value = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder getValueBuilder() { + bitField0_ |= 0x00000004; + onChanged(); + return getValueFieldBuilder().getBuilder(); + } + /** + * 
+       ** an expression to be computed as the new value for the operation 
+       *
+ * + * optional .Mysqlx.Expr.Expr value = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getValueOrBuilder() { + if (valueBuilder_ != null) { + return valueBuilder_.getMessageOrBuilder(); + } else { + return value_ == null ? + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : value_; + } + } + /** + * 
+       ** an expression to be computed as the new value for the operation 
+       *
+ * + * optional .Mysqlx.Expr.Expr value = 3; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> + getValueFieldBuilder() { + if (valueBuilder_ == null) { + valueBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder>( + getValue(), + getParentForChildren(), + isClean()); + value_ = null; + } + return valueBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Crud.UpdateOperation) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Crud.UpdateOperation) + private static final com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation(); + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public UpdateOperation parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new UpdateOperation(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface FindOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Crud.Find) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** collection in which to find 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + * @return Whether the collection field is set. + */ + boolean hasCollection(); + /** + * 
+     ** collection in which to find 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + * @return The collection. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Collection getCollection(); + /** + * 
+     ** collection in which to find 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder getCollectionOrBuilder(); + + /** + * 
+     ** data model that the operations refer to 
+     *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 3; + * @return Whether the dataModel field is set. + */ + boolean hasDataModel(); + /** + * 
+     ** data model that the operations refer to 
+     *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 3; + * @return The dataModel. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.DataModel getDataModel(); + + /** + * 
+     ** list of column projections that shall be returned 
+     *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + java.util.List + getProjectionList(); + /** + * 
+     ** list of column projections that shall be returned 
+     *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Projection getProjection(int index); + /** + * 
+     ** list of column projections that shall be returned 
+     *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + int getProjectionCount(); + /** + * 
+     ** list of column projections that shall be returned 
+     *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + java.util.List + getProjectionOrBuilderList(); + /** + * 
+     ** list of column projections that shall be returned 
+     *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.ProjectionOrBuilder getProjectionOrBuilder( + int index); + + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + java.util.List + getArgsList(); + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getArgs(int index); + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + int getArgsCount(); + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + java.util.List + getArgsOrBuilderList(); + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getArgsOrBuilder( + int index); + + /** + * 
+     ** filter criteria 
+     *
+ * + * optional .Mysqlx.Expr.Expr criteria = 5; + * @return Whether the criteria field is set. + */ + boolean hasCriteria(); + /** + * 
+     ** filter criteria 
+     *
+ * + * optional .Mysqlx.Expr.Expr criteria = 5; + * @return The criteria. + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Expr getCriteria(); + /** + * 
+     ** filter criteria 
+     *
+ * + * optional .Mysqlx.Expr.Expr criteria = 5; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getCriteriaOrBuilder(); + + /** + * 
+     ** numbers of rows that shall be skipped and returned
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.Limit limit = 6; + * @return Whether the limit field is set. + */ + boolean hasLimit(); + /** + * 
+     ** numbers of rows that shall be skipped and returned
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.Limit limit = 6; + * @return The limit. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Limit getLimit(); + /** + * 
+     ** numbers of rows that shall be skipped and returned
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.Limit limit = 6; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.LimitOrBuilder getLimitOrBuilder(); + + /** + * 
+     ** sort-order in which the rows/document shall be returned in 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + java.util.List + getOrderList(); + /** + * 
+     ** sort-order in which the rows/document shall be returned in 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Order getOrder(int index); + /** + * 
+     ** sort-order in which the rows/document shall be returned in 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + int getOrderCount(); + /** + * 
+     ** sort-order in which the rows/document shall be returned in 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + java.util.List + getOrderOrBuilderList(); + /** + * 
+     ** sort-order in which the rows/document shall be returned in 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.OrderOrBuilder getOrderOrBuilder( + int index); + + /** + * 
+     ** column expression list for aggregation (GROUP BY) 
+     *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + java.util.List + getGroupingList(); + /** + * 
+     ** column expression list for aggregation (GROUP BY) 
+     *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Expr getGrouping(int index); + /** + * 
+     ** column expression list for aggregation (GROUP BY) 
+     *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + int getGroupingCount(); + /** + * 
+     ** column expression list for aggregation (GROUP BY) 
+     *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + java.util.List + getGroupingOrBuilderList(); + /** + * 
+     ** column expression list for aggregation (GROUP BY) 
+     *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getGroupingOrBuilder( + int index); + + /** + * 
+     ** filter criteria for aggregated groups 
+     *
+ * + * optional .Mysqlx.Expr.Expr grouping_criteria = 9; + * @return Whether the groupingCriteria field is set. + */ + boolean hasGroupingCriteria(); + /** + * 
+     ** filter criteria for aggregated groups 
+     *
+ * + * optional .Mysqlx.Expr.Expr grouping_criteria = 9; + * @return The groupingCriteria. + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Expr getGroupingCriteria(); + /** + * 
+     ** filter criteria for aggregated groups 
+     *
+ * + * optional .Mysqlx.Expr.Expr grouping_criteria = 9; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getGroupingCriteriaOrBuilder(); + + /** + * 
+     ** perform row locking on matches 
+     *
+ * + * optional .Mysqlx.Crud.Find.RowLock locking = 12; + * @return Whether the locking field is set. + */ + boolean hasLocking(); + /** + * 
+     ** perform row locking on matches 
+     *
+ * + * optional .Mysqlx.Crud.Find.RowLock locking = 12; + * @return The locking. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLock getLocking(); + + /** + * 
+     ** additional options how to handle locked rows 
+     *
+ * + * optional .Mysqlx.Crud.Find.RowLockOptions locking_options = 13; + * @return Whether the lockingOptions field is set. + */ + boolean hasLockingOptions(); + /** + * 
+     ** additional options how to handle locked rows 
+     *
+ * + * optional .Mysqlx.Crud.Find.RowLockOptions locking_options = 13; + * @return The lockingOptions. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLockOptions getLockingOptions(); + + /** + * 
+     ** numbers of rows that shall be skipped and returned
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 14; + * @return Whether the limitExpr field is set. + */ + boolean hasLimitExpr(); + /** + * 
+     ** numbers of rows that shall be skipped and returned
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 14; + * @return The limitExpr. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr getLimitExpr(); + /** + * 
+     ** numbers of rows that shall be skipped and returned
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 14; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExprOrBuilder getLimitExprOrBuilder(); + } + /** + * 
+   **
+   *Find Documents/Rows in a Collection/Table
+   *@startuml
+   *client -> server: Find
+   *... one or more Resultset ...
+   *@enduml
+   *@returns @ref Mysqlx::Resultset
+   *
+ * + * Protobuf type {@code Mysqlx.Crud.Find} + */ + public static final class Find extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Crud.Find) + FindOrBuilder { + private static final long serialVersionUID = 0L; + // Use Find.newBuilder() to construct. + private Find(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Find() { + dataModel_ = 1; + projection_ = java.util.Collections.emptyList(); + args_ = java.util.Collections.emptyList(); + order_ = java.util.Collections.emptyList(); + grouping_ = java.util.Collections.emptyList(); + locking_ = 1; + lockingOptions_ = 1; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Find(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Find( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 18: { + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) != 0)) { + subBuilder = collection_.toBuilder(); + } + collection_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Collection.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(collection_); + collection_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 24: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.DataModel value = com.mysql.cj.x.protobuf.MysqlxCrud.DataModel.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(3, rawValue); + } else { + bitField0_ |= 0x00000002; + dataModel_ = rawValue; + } + break; + } + case 34: { + if (!((mutable_bitField0_ & 0x00000004) != 0)) { + projection_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000004; + } + projection_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Projection.PARSER, extensionRegistry)); + break; + } + case 42: { + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) != 0)) { + subBuilder = criteria_.toBuilder(); + } + criteria_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.Expr.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(criteria_); + criteria_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 50: { + com.mysql.cj.x.protobuf.MysqlxCrud.Limit.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) != 0)) { + subBuilder = limit_.toBuilder(); + } + limit_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Limit.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(limit_); + limit_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + break; + } + case 58: { + if (!((mutable_bitField0_ & 0x00000040) != 0)) { + order_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000040; + } + order_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Order.PARSER, extensionRegistry)); + break; + } + case 66: { + if (!((mutable_bitField0_ & 0x00000080) != 0)) { + grouping_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000080; + } + grouping_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.Expr.PARSER, extensionRegistry)); + break; + } + case 74: { + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder subBuilder = null; + if (((bitField0_ & 0x00000010) != 0)) { + subBuilder = groupingCriteria_.toBuilder(); + } + groupingCriteria_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.Expr.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(groupingCriteria_); + groupingCriteria_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000010; + break; + } + case 90: { + if (!((mutable_bitField0_ & 0x00000008) != 0)) { + args_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000008; + } + args_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.PARSER, extensionRegistry)); + break; + } + case 96: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLock value = com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLock.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(12, rawValue); + } else { + bitField0_ |= 0x00000020; + locking_ = rawValue; + } + break; + } + case 104: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLockOptions value = com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLockOptions.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(13, rawValue); + } else { + bitField0_ |= 0x00000040; + lockingOptions_ = rawValue; + } + break; + } + case 114: { + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.Builder subBuilder = null; + if (((bitField0_ & 0x00000080) != 0)) { + subBuilder = limitExpr_.toBuilder(); + } + limitExpr_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(limitExpr_); + limitExpr_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000080; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000004) != 0)) { + projection_ = java.util.Collections.unmodifiableList(projection_); + } + if (((mutable_bitField0_ & 0x00000040) != 0)) { + order_ = java.util.Collections.unmodifiableList(order_); + } + if (((mutable_bitField0_ & 0x00000080) != 0)) { + grouping_ = java.util.Collections.unmodifiableList(grouping_); + } + if (((mutable_bitField0_ & 0x00000008) != 0)) { + args_ = java.util.Collections.unmodifiableList(args_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Find_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Find_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.Find.class, com.mysql.cj.x.protobuf.MysqlxCrud.Find.Builder.class); + } + + /** + * Protobuf enum {@code Mysqlx.Crud.Find.RowLock} + */ + public enum RowLock + implements com.google.protobuf.ProtocolMessageEnum { + /** + * 
+       ** Lock matching rows against updates 
+       *
+ * + * SHARED_LOCK = 1; + */ + SHARED_LOCK(1), + /** + * 
+       ** Lock matching rows so no other transaction can read or write to it 
+       *
+ * + * EXCLUSIVE_LOCK = 2; + */ + EXCLUSIVE_LOCK(2), + ; + + /** + * 
+       ** Lock matching rows against updates 
+       *
+ * + * SHARED_LOCK = 1; + */ + public static final int SHARED_LOCK_VALUE = 1; + /** + * 
+       ** Lock matching rows so no other transaction can read or write to it 
+       *
+ * + * EXCLUSIVE_LOCK = 2; + */ + public static final int EXCLUSIVE_LOCK_VALUE = 2; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static RowLock valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static RowLock forNumber(int value) { + switch (value) { + case 1: return SHARED_LOCK; + case 2: return EXCLUSIVE_LOCK; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + RowLock> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public RowLock findValueByNumber(int number) { + return RowLock.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.Find.getDescriptor().getEnumTypes().get(0); + } + + private static final RowLock[] VALUES = values(); + + public static RowLock valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private RowLock(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Crud.Find.RowLock) + } + + /** + * Protobuf enum {@code Mysqlx.Crud.Find.RowLockOptions} + */ + public enum RowLockOptions + implements com.google.protobuf.ProtocolMessageEnum { + /** + * 
+       ** Do not wait to acquire row lock, fail with an error
+       *if a requested row is locked 
+       *
+ * + * NOWAIT = 1; + */ + NOWAIT(1), + /** + * 
+       ** Do not wait to acquire a row lock,
+       *remove locked rows from the result set 
+       *
+ * + * SKIP_LOCKED = 2; + */ + SKIP_LOCKED(2), + ; + + /** + * 
+       ** Do not wait to acquire row lock, fail with an error
+       *if a requested row is locked 
+       *
+ * + * NOWAIT = 1; + */ + public static final int NOWAIT_VALUE = 1; + /** + * 
+       ** Do not wait to acquire a row lock,
+       *remove locked rows from the result set 
+       *
+ * + * SKIP_LOCKED = 2; + */ + public static final int SKIP_LOCKED_VALUE = 2; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static RowLockOptions valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static RowLockOptions forNumber(int value) { + switch (value) { + case 1: return NOWAIT; + case 2: return SKIP_LOCKED; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + RowLockOptions> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public RowLockOptions findValueByNumber(int number) { + return RowLockOptions.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.Find.getDescriptor().getEnumTypes().get(1); + } + + private static final RowLockOptions[] VALUES = values(); + + public static RowLockOptions valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private RowLockOptions(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Crud.Find.RowLockOptions) + } + + private int bitField0_; + public static final int COLLECTION_FIELD_NUMBER = 2; + private com.mysql.cj.x.protobuf.MysqlxCrud.Collection collection_; + /** + * 
+     ** collection in which to find 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + * @return Whether the collection field is set. + */ + public boolean hasCollection() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** collection in which to find 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + * @return The collection. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection getCollection() { + return collection_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } + /** + * 
+     ** collection in which to find 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder getCollectionOrBuilder() { + return collection_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } + + public static final int DATA_MODEL_FIELD_NUMBER = 3; + private int dataModel_; + /** + * 
+     ** data model that the operations refer to 
+     *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 3; + * @return Whether the dataModel field is set. + */ + public boolean hasDataModel() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** data model that the operations refer to 
+     *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 3; + * @return The dataModel. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.DataModel getDataModel() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.DataModel result = com.mysql.cj.x.protobuf.MysqlxCrud.DataModel.valueOf(dataModel_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.DataModel.DOCUMENT : result; + } + + public static final int PROJECTION_FIELD_NUMBER = 4; + private java.util.List projection_; + /** + * 
+     ** list of column projections that shall be returned 
+     *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public java.util.List getProjectionList() { + return projection_; + } + /** + * 
+     ** list of column projections that shall be returned 
+     *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public java.util.List + getProjectionOrBuilderList() { + return projection_; + } + /** + * 
+     ** list of column projections that shall be returned 
+     *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public int getProjectionCount() { + return projection_.size(); + } + /** + * 
+     ** list of column projections that shall be returned 
+     *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Projection getProjection(int index) { + return projection_.get(index); + } + /** + * 
+     ** list of column projections that shall be returned 
+     *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.ProjectionOrBuilder getProjectionOrBuilder( + int index) { + return projection_.get(index); + } + + public static final int ARGS_FIELD_NUMBER = 11; + private java.util.List args_; + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public java.util.List getArgsList() { + return args_; + } + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public java.util.List + getArgsOrBuilderList() { + return args_; + } + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public int getArgsCount() { + return args_.size(); + } + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getArgs(int index) { + return args_.get(index); + } + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getArgsOrBuilder( + int index) { + return args_.get(index); + } + + public static final int CRITERIA_FIELD_NUMBER = 5; + private com.mysql.cj.x.protobuf.MysqlxExpr.Expr criteria_; + /** + * 
+     ** filter criteria 
+     *
+ * + * optional .Mysqlx.Expr.Expr criteria = 5; + * @return Whether the criteria field is set. + */ + public boolean hasCriteria() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+     ** filter criteria 
+     *
+ * + * optional .Mysqlx.Expr.Expr criteria = 5; + * @return The criteria. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getCriteria() { + return criteria_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : criteria_; + } + /** + * 
+     ** filter criteria 
+     *
+ * + * optional .Mysqlx.Expr.Expr criteria = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getCriteriaOrBuilder() { + return criteria_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : criteria_; + } + + public static final int LIMIT_FIELD_NUMBER = 6; + private com.mysql.cj.x.protobuf.MysqlxCrud.Limit limit_; + /** + * 
+     ** numbers of rows that shall be skipped and returned
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.Limit limit = 6; + * @return Whether the limit field is set. + */ + public boolean hasLimit() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * 
+     ** numbers of rows that shall be skipped and returned
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.Limit limit = 6; + * @return The limit. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Limit getLimit() { + return limit_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Limit.getDefaultInstance() : limit_; + } + /** + * 
+     ** numbers of rows that shall be skipped and returned
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.Limit limit = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitOrBuilder getLimitOrBuilder() { + return limit_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Limit.getDefaultInstance() : limit_; + } + + public static final int ORDER_FIELD_NUMBER = 7; + private java.util.List order_; + /** + * 
+     ** sort-order in which the rows/document shall be returned in 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public java.util.List getOrderList() { + return order_; + } + /** + * 
+     ** sort-order in which the rows/document shall be returned in 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public java.util.List + getOrderOrBuilderList() { + return order_; + } + /** + * 
+     ** sort-order in which the rows/document shall be returned in 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public int getOrderCount() { + return order_.size(); + } + /** + * 
+     ** sort-order in which the rows/document shall be returned in 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Order getOrder(int index) { + return order_.get(index); + } + /** + * 
+     ** sort-order in which the rows/document shall be returned in 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.OrderOrBuilder getOrderOrBuilder( + int index) { + return order_.get(index); + } + + public static final int GROUPING_FIELD_NUMBER = 8; + private java.util.List grouping_; + /** + * 
+     ** column expression list for aggregation (GROUP BY) 
+     *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public java.util.List getGroupingList() { + return grouping_; + } + /** + * 
+     ** column expression list for aggregation (GROUP BY) 
+     *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public java.util.List + getGroupingOrBuilderList() { + return grouping_; + } + /** + * 
+     ** column expression list for aggregation (GROUP BY) 
+     *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public int getGroupingCount() { + return grouping_.size(); + } + /** + * 
+     ** column expression list for aggregation (GROUP BY) 
+     *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getGrouping(int index) { + return grouping_.get(index); + } + /** + * 
+     ** column expression list for aggregation (GROUP BY) 
+     *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getGroupingOrBuilder( + int index) { + return grouping_.get(index); + } + + public static final int GROUPING_CRITERIA_FIELD_NUMBER = 9; + private com.mysql.cj.x.protobuf.MysqlxExpr.Expr groupingCriteria_; + /** + * 
+     ** filter criteria for aggregated groups 
+     *
+ * + * optional .Mysqlx.Expr.Expr grouping_criteria = 9; + * @return Whether the groupingCriteria field is set. + */ + public boolean hasGroupingCriteria() { + return ((bitField0_ & 0x00000010) != 0); + } + /** + * 
+     ** filter criteria for aggregated groups 
+     *
+ * + * optional .Mysqlx.Expr.Expr grouping_criteria = 9; + * @return The groupingCriteria. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getGroupingCriteria() { + return groupingCriteria_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : groupingCriteria_; + } + /** + * 
+     ** filter criteria for aggregated groups 
+     *
+ * + * optional .Mysqlx.Expr.Expr grouping_criteria = 9; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getGroupingCriteriaOrBuilder() { + return groupingCriteria_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : groupingCriteria_; + } + + public static final int LOCKING_FIELD_NUMBER = 12; + private int locking_; + /** + * 
+     ** perform row locking on matches 
+     *
+ * + * optional .Mysqlx.Crud.Find.RowLock locking = 12; + * @return Whether the locking field is set. + */ + public boolean hasLocking() { + return ((bitField0_ & 0x00000020) != 0); + } + /** + * 
+     ** perform row locking on matches 
+     *
+ * + * optional .Mysqlx.Crud.Find.RowLock locking = 12; + * @return The locking. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLock getLocking() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLock result = com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLock.valueOf(locking_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLock.SHARED_LOCK : result; + } + + public static final int LOCKING_OPTIONS_FIELD_NUMBER = 13; + private int lockingOptions_; + /** + * 
+     ** additional options how to handle locked rows 
+     *
+ * + * optional .Mysqlx.Crud.Find.RowLockOptions locking_options = 13; + * @return Whether the lockingOptions field is set. + */ + public boolean hasLockingOptions() { + return ((bitField0_ & 0x00000040) != 0); + } + /** + * 
+     ** additional options how to handle locked rows 
+     *
+ * + * optional .Mysqlx.Crud.Find.RowLockOptions locking_options = 13; + * @return The lockingOptions. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLockOptions getLockingOptions() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLockOptions result = com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLockOptions.valueOf(lockingOptions_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLockOptions.NOWAIT : result; + } + + public static final int LIMIT_EXPR_FIELD_NUMBER = 14; + private com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr limitExpr_; + /** + * 
+     ** numbers of rows that shall be skipped and returned
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 14; + * @return Whether the limitExpr field is set. + */ + public boolean hasLimitExpr() { + return ((bitField0_ & 0x00000080) != 0); + } + /** + * 
+     ** numbers of rows that shall be skipped and returned
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 14; + * @return The limitExpr. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr getLimitExpr() { + return limitExpr_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.getDefaultInstance() : limitExpr_; + } + /** + * 
+     ** numbers of rows that shall be skipped and returned
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 14; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitExprOrBuilder getLimitExprOrBuilder() { + return limitExpr_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.getDefaultInstance() : limitExpr_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasCollection()) { + memoizedIsInitialized = 0; + return false; + } + if (!getCollection().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + for (int i = 0; i < getProjectionCount(); i++) { + if (!getProjection(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + for (int i = 0; i < getArgsCount(); i++) { + if (!getArgs(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasCriteria()) { + if (!getCriteria().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasLimit()) { + if (!getLimit().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + for (int i = 0; i < getOrderCount(); i++) { + if (!getOrder(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + for (int i = 0; i < getGroupingCount(); i++) { + if (!getGrouping(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasGroupingCriteria()) { + if (!getGroupingCriteria().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasLimitExpr()) { + if (!getLimitExpr().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeMessage(2, getCollection()); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeEnum(3, dataModel_); + } + for (int i = 0; i < projection_.size(); i++) { + output.writeMessage(4, projection_.get(i)); + } + if (((bitField0_ & 0x00000004) != 0)) { + output.writeMessage(5, getCriteria()); + } + if (((bitField0_ & 0x00000008) != 0)) { + output.writeMessage(6, getLimit()); + } + for (int i = 0; i < order_.size(); i++) { + output.writeMessage(7, order_.get(i)); + } + for (int i = 0; i < grouping_.size(); i++) { + output.writeMessage(8, grouping_.get(i)); + } + if (((bitField0_ & 0x00000010) != 0)) { + output.writeMessage(9, getGroupingCriteria()); + } + for (int i = 0; i < args_.size(); i++) { + output.writeMessage(11, args_.get(i)); + } + if (((bitField0_ & 0x00000020) != 0)) { + output.writeEnum(12, locking_); + } + if (((bitField0_ & 0x00000040) != 0)) { + output.writeEnum(13, lockingOptions_); + } + if (((bitField0_ & 0x00000080) != 0)) { + output.writeMessage(14, getLimitExpr()); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, getCollection()); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(3, dataModel_); + } + for (int i = 0; i < projection_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, projection_.get(i)); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(5, getCriteria()); + } + if (((bitField0_ & 0x00000008) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(6, getLimit()); + } + for (int i = 0; i < order_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(7, order_.get(i)); + } + for (int i = 0; i < grouping_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(8, grouping_.get(i)); + } + if (((bitField0_ & 0x00000010) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(9, getGroupingCriteria()); + } + for (int i = 0; i < args_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(11, args_.get(i)); + } + if (((bitField0_ & 0x00000020) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(12, locking_); + } + if (((bitField0_ & 0x00000040) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(13, lockingOptions_); + } + if (((bitField0_ & 0x00000080) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(14, getLimitExpr()); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxCrud.Find)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxCrud.Find other = (com.mysql.cj.x.protobuf.MysqlxCrud.Find) obj; + + if (hasCollection() != other.hasCollection()) return false; + if (hasCollection()) { + if (!getCollection() + .equals(other.getCollection())) return false; + } + if (hasDataModel() != other.hasDataModel()) return false; + if (hasDataModel()) { + if (dataModel_ != other.dataModel_) return false; + } + if (!getProjectionList() + .equals(other.getProjectionList())) return false; + if (!getArgsList() + .equals(other.getArgsList())) return false; + if (hasCriteria() != other.hasCriteria()) return false; + if (hasCriteria()) { + if (!getCriteria() + .equals(other.getCriteria())) return false; + } + if (hasLimit() != other.hasLimit()) return false; + if (hasLimit()) { + if (!getLimit() + .equals(other.getLimit())) return false; + } + if (!getOrderList() + .equals(other.getOrderList())) return false; + if (!getGroupingList() + .equals(other.getGroupingList())) return false; + if (hasGroupingCriteria() != other.hasGroupingCriteria()) return false; + if (hasGroupingCriteria()) { + if (!getGroupingCriteria() + .equals(other.getGroupingCriteria())) return false; + } + if (hasLocking() != other.hasLocking()) return false; + if (hasLocking()) { + if (locking_ != other.locking_) return false; + } + if (hasLockingOptions() != other.hasLockingOptions()) return false; + if (hasLockingOptions()) { + if (lockingOptions_ != other.lockingOptions_) return false; + } + if (hasLimitExpr() != other.hasLimitExpr()) return false; + if (hasLimitExpr()) { + if (!getLimitExpr() + .equals(other.getLimitExpr())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasCollection()) { + hash = (37 * hash) + COLLECTION_FIELD_NUMBER; + hash = (53 * hash) + getCollection().hashCode(); + } + if (hasDataModel()) { + hash = (37 * hash) + DATA_MODEL_FIELD_NUMBER; + hash = (53 * hash) + dataModel_; + } + if (getProjectionCount() > 0) { + hash = (37 * hash) + PROJECTION_FIELD_NUMBER; + hash = (53 * hash) + getProjectionList().hashCode(); + } + if (getArgsCount() > 0) { + hash = (37 * hash) + ARGS_FIELD_NUMBER; + hash = (53 * hash) + getArgsList().hashCode(); + } + if (hasCriteria()) { + hash = (37 * hash) + CRITERIA_FIELD_NUMBER; + hash = (53 * hash) + getCriteria().hashCode(); + } + if (hasLimit()) { + hash = (37 * hash) + LIMIT_FIELD_NUMBER; + hash = (53 * hash) + getLimit().hashCode(); + } + if (getOrderCount() > 0) { + hash = (37 * hash) + ORDER_FIELD_NUMBER; + hash = (53 * hash) + getOrderList().hashCode(); + } + if (getGroupingCount() > 0) { + hash = (37 * hash) + GROUPING_FIELD_NUMBER; + hash = (53 * hash) + getGroupingList().hashCode(); + } + if (hasGroupingCriteria()) { + hash = (37 * hash) + GROUPING_CRITERIA_FIELD_NUMBER; + hash = (53 * hash) + getGroupingCriteria().hashCode(); + } + if (hasLocking()) { + hash = (37 * hash) + LOCKING_FIELD_NUMBER; + hash = (53 * hash) + locking_; + } + if (hasLockingOptions()) { + hash = (37 * hash) + LOCKING_OPTIONS_FIELD_NUMBER; + hash = (53 * hash) + lockingOptions_; + } + if (hasLimitExpr()) { + hash = (37 * hash) + LIMIT_EXPR_FIELD_NUMBER; + hash = (53 * hash) + getLimitExpr().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.Find parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Find parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Find parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Find parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Find parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Find parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Find parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Find parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Find parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Find parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Find parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Find parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxCrud.Find prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Find Documents/Rows in a Collection/Table
+     *@startuml
+     *client -> server: Find
+     *... one or more Resultset ...
+     *@enduml
+     *@returns @ref Mysqlx::Resultset
+     *
+ * + * Protobuf type {@code Mysqlx.Crud.Find} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Crud.Find) + com.mysql.cj.x.protobuf.MysqlxCrud.FindOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Find_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Find_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.Find.class, com.mysql.cj.x.protobuf.MysqlxCrud.Find.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxCrud.Find.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getCollectionFieldBuilder(); + getProjectionFieldBuilder(); + getArgsFieldBuilder(); + getCriteriaFieldBuilder(); + getLimitFieldBuilder(); + getOrderFieldBuilder(); + getGroupingFieldBuilder(); + getGroupingCriteriaFieldBuilder(); + getLimitExprFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + if (collectionBuilder_ == null) { + collection_ = null; + } else { + collectionBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + dataModel_ = 1; + bitField0_ = (bitField0_ & ~0x00000002); + if (projectionBuilder_ == null) { + projection_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + } else { + projectionBuilder_.clear(); + } + if (argsBuilder_ == null) { + args_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000008); + } else { + argsBuilder_.clear(); + } + if (criteriaBuilder_ == null) { + criteria_ = null; + } else { + criteriaBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000010); + if (limitBuilder_ == null) { + limit_ = null; + } else { + limitBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000020); + if (orderBuilder_ == null) { + order_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000040); + } else { + orderBuilder_.clear(); + } + if (groupingBuilder_ == null) { + grouping_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000080); + } else { + groupingBuilder_.clear(); + } + if (groupingCriteriaBuilder_ == null) { + groupingCriteria_ = null; + } else { + groupingCriteriaBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000100); + locking_ = 1; + bitField0_ = (bitField0_ & ~0x00000200); + lockingOptions_ = 1; + bitField0_ = (bitField0_ & ~0x00000400); + if (limitExprBuilder_ == null) { + limitExpr_ = null; + } else { + limitExprBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000800); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Find_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Find getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.Find.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Find build() { + com.mysql.cj.x.protobuf.MysqlxCrud.Find result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Find buildPartial() { + com.mysql.cj.x.protobuf.MysqlxCrud.Find result = new com.mysql.cj.x.protobuf.MysqlxCrud.Find(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + if (collectionBuilder_ == null) { + result.collection_ = collection_; + } else { + result.collection_ = collectionBuilder_.build(); + } + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + to_bitField0_ |= 0x00000002; + } + result.dataModel_ = dataModel_; + if (projectionBuilder_ == null) { + if (((bitField0_ & 0x00000004) != 0)) { + projection_ = java.util.Collections.unmodifiableList(projection_); + bitField0_ = (bitField0_ & ~0x00000004); + } + result.projection_ = projection_; + } else { + result.projection_ = projectionBuilder_.build(); + } + if (argsBuilder_ == null) { + if (((bitField0_ & 0x00000008) != 0)) { + args_ = java.util.Collections.unmodifiableList(args_); + bitField0_ = (bitField0_ & ~0x00000008); + } + result.args_ = args_; + } else { + result.args_ = argsBuilder_.build(); + } + if (((from_bitField0_ & 0x00000010) != 0)) { + if (criteriaBuilder_ == null) { + result.criteria_ = criteria_; + } else { + result.criteria_ = criteriaBuilder_.build(); + } + to_bitField0_ |= 0x00000004; + } + if (((from_bitField0_ & 0x00000020) != 0)) { + if (limitBuilder_ == null) { + result.limit_ = limit_; + } else { + result.limit_ = limitBuilder_.build(); + } + to_bitField0_ |= 0x00000008; + } + if (orderBuilder_ == null) { + if (((bitField0_ & 0x00000040) != 0)) { + order_ = java.util.Collections.unmodifiableList(order_); + bitField0_ = (bitField0_ & ~0x00000040); + } + result.order_ = order_; + } else { + result.order_ = orderBuilder_.build(); + } + if (groupingBuilder_ == null) { + if (((bitField0_ & 0x00000080) != 0)) { + grouping_ = java.util.Collections.unmodifiableList(grouping_); + bitField0_ = (bitField0_ & ~0x00000080); + } + result.grouping_ = grouping_; + } else { + result.grouping_ = groupingBuilder_.build(); + } + if (((from_bitField0_ & 0x00000100) != 0)) { + if (groupingCriteriaBuilder_ == null) { + result.groupingCriteria_ = groupingCriteria_; + } else { + result.groupingCriteria_ = groupingCriteriaBuilder_.build(); + } + to_bitField0_ |= 0x00000010; + } + if (((from_bitField0_ & 0x00000200) != 0)) { + to_bitField0_ |= 0x00000020; + } + result.locking_ = locking_; + if (((from_bitField0_ & 0x00000400) != 0)) { + to_bitField0_ |= 0x00000040; + } + result.lockingOptions_ = lockingOptions_; + if (((from_bitField0_ & 0x00000800) != 0)) { + if (limitExprBuilder_ == null) { + result.limitExpr_ = limitExpr_; + } else { + result.limitExpr_ = limitExprBuilder_.build(); + } + to_bitField0_ |= 0x00000080; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxCrud.Find) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxCrud.Find)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxCrud.Find other) { + if (other == com.mysql.cj.x.protobuf.MysqlxCrud.Find.getDefaultInstance()) return this; + if (other.hasCollection()) { + mergeCollection(other.getCollection()); + } + if (other.hasDataModel()) { + setDataModel(other.getDataModel()); + } + if (projectionBuilder_ == null) { + if (!other.projection_.isEmpty()) { + if (projection_.isEmpty()) { + projection_ = other.projection_; + bitField0_ = (bitField0_ & ~0x00000004); + } else { + ensureProjectionIsMutable(); + projection_.addAll(other.projection_); + } + onChanged(); + } + } else { + if (!other.projection_.isEmpty()) { + if (projectionBuilder_.isEmpty()) { + projectionBuilder_.dispose(); + projectionBuilder_ = null; + projection_ = other.projection_; + bitField0_ = (bitField0_ & ~0x00000004); + projectionBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getProjectionFieldBuilder() : null; + } else { + projectionBuilder_.addAllMessages(other.projection_); + } + } + } + if (argsBuilder_ == null) { + if (!other.args_.isEmpty()) { + if (args_.isEmpty()) { + args_ = other.args_; + bitField0_ = (bitField0_ & ~0x00000008); + } else { + ensureArgsIsMutable(); + args_.addAll(other.args_); + } + onChanged(); + } + } else { + if (!other.args_.isEmpty()) { + if (argsBuilder_.isEmpty()) { + argsBuilder_.dispose(); + argsBuilder_ = null; + args_ = other.args_; + bitField0_ = (bitField0_ & ~0x00000008); + argsBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getArgsFieldBuilder() : null; + } else { + argsBuilder_.addAllMessages(other.args_); + } + } + } + if (other.hasCriteria()) { + mergeCriteria(other.getCriteria()); + } + if (other.hasLimit()) { + mergeLimit(other.getLimit()); + } + if (orderBuilder_ == null) { + if (!other.order_.isEmpty()) { + if (order_.isEmpty()) { + order_ = other.order_; + bitField0_ = (bitField0_ & ~0x00000040); + } else { + ensureOrderIsMutable(); + order_.addAll(other.order_); + } + onChanged(); + } + } else { + if (!other.order_.isEmpty()) { + if (orderBuilder_.isEmpty()) { + orderBuilder_.dispose(); + orderBuilder_ = null; + order_ = other.order_; + bitField0_ = (bitField0_ & ~0x00000040); + orderBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getOrderFieldBuilder() : null; + } else { + orderBuilder_.addAllMessages(other.order_); + } + } + } + if (groupingBuilder_ == null) { + if (!other.grouping_.isEmpty()) { + if (grouping_.isEmpty()) { + grouping_ = other.grouping_; + bitField0_ = (bitField0_ & ~0x00000080); + } else { + ensureGroupingIsMutable(); + grouping_.addAll(other.grouping_); + } + onChanged(); + } + } else { + if (!other.grouping_.isEmpty()) { + if (groupingBuilder_.isEmpty()) { + groupingBuilder_.dispose(); + groupingBuilder_ = null; + grouping_ = other.grouping_; + bitField0_ = (bitField0_ & ~0x00000080); + groupingBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getGroupingFieldBuilder() : null; + } else { + groupingBuilder_.addAllMessages(other.grouping_); + } + } + } + if (other.hasGroupingCriteria()) { + mergeGroupingCriteria(other.getGroupingCriteria()); + } + if (other.hasLocking()) { + setLocking(other.getLocking()); + } + if (other.hasLockingOptions()) { + setLockingOptions(other.getLockingOptions()); + } + if (other.hasLimitExpr()) { + mergeLimitExpr(other.getLimitExpr()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasCollection()) { + return false; + } + if (!getCollection().isInitialized()) { + return false; + } + for (int i = 0; i < getProjectionCount(); i++) { + if (!getProjection(i).isInitialized()) { + return false; + } + } + for (int i = 0; i < getArgsCount(); i++) { + if (!getArgs(i).isInitialized()) { + return false; + } + } + if (hasCriteria()) { + if (!getCriteria().isInitialized()) { + return false; + } + } + if (hasLimit()) { + if (!getLimit().isInitialized()) { + return false; + } + } + for (int i = 0; i < getOrderCount(); i++) { + if (!getOrder(i).isInitialized()) { + return false; + } + } + for (int i = 0; i < getGroupingCount(); i++) { + if (!getGrouping(i).isInitialized()) { + return false; + } + } + if (hasGroupingCriteria()) { + if (!getGroupingCriteria().isInitialized()) { + return false; + } + } + if (hasLimitExpr()) { + if (!getLimitExpr().isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxCrud.Find parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxCrud.Find) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private com.mysql.cj.x.protobuf.MysqlxCrud.Collection collection_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Collection, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder> collectionBuilder_; + /** + * 
+       ** collection in which to find 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + * @return Whether the collection field is set. + */ + public boolean hasCollection() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** collection in which to find 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + * @return The collection. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection getCollection() { + if (collectionBuilder_ == null) { + return collection_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } else { + return collectionBuilder_.getMessage(); + } + } + /** + * 
+       ** collection in which to find 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + */ + public Builder setCollection(com.mysql.cj.x.protobuf.MysqlxCrud.Collection value) { + if (collectionBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + collection_ = value; + onChanged(); + } else { + collectionBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** collection in which to find 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + */ + public Builder setCollection( + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder builderForValue) { + if (collectionBuilder_ == null) { + collection_ = builderForValue.build(); + onChanged(); + } else { + collectionBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** collection in which to find 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + */ + public Builder mergeCollection(com.mysql.cj.x.protobuf.MysqlxCrud.Collection value) { + if (collectionBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0) && + collection_ != null && + collection_ != com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance()) { + collection_ = + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.newBuilder(collection_).mergeFrom(value).buildPartial(); + } else { + collection_ = value; + } + onChanged(); + } else { + collectionBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** collection in which to find 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + */ + public Builder clearCollection() { + if (collectionBuilder_ == null) { + collection_ = null; + onChanged(); + } else { + collectionBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + /** + * 
+       ** collection in which to find 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder getCollectionBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getCollectionFieldBuilder().getBuilder(); + } + /** + * 
+       ** collection in which to find 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder getCollectionOrBuilder() { + if (collectionBuilder_ != null) { + return collectionBuilder_.getMessageOrBuilder(); + } else { + return collection_ == null ? + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } + } + /** + * 
+       ** collection in which to find 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Collection, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder> + getCollectionFieldBuilder() { + if (collectionBuilder_ == null) { + collectionBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Collection, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder>( + getCollection(), + getParentForChildren(), + isClean()); + collection_ = null; + } + return collectionBuilder_; + } + + private int dataModel_ = 1; + /** + * 
+       ** data model that the operations refer to 
+       *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 3; + * @return Whether the dataModel field is set. + */ + public boolean hasDataModel() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** data model that the operations refer to 
+       *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 3; + * @return The dataModel. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.DataModel getDataModel() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.DataModel result = com.mysql.cj.x.protobuf.MysqlxCrud.DataModel.valueOf(dataModel_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.DataModel.DOCUMENT : result; + } + /** + * 
+       ** data model that the operations refer to 
+       *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 3; + * @param value The dataModel to set. + * @return This builder for chaining. + */ + public Builder setDataModel(com.mysql.cj.x.protobuf.MysqlxCrud.DataModel value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + dataModel_ = value.getNumber(); + onChanged(); + return this; + } + /** + * 
+       ** data model that the operations refer to 
+       *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 3; + * @return This builder for chaining. + */ + public Builder clearDataModel() { + bitField0_ = (bitField0_ & ~0x00000002); + dataModel_ = 1; + onChanged(); + return this; + } + + private java.util.List projection_ = + java.util.Collections.emptyList(); + private void ensureProjectionIsMutable() { + if (!((bitField0_ & 0x00000004) != 0)) { + projection_ = new java.util.ArrayList(projection_); + bitField0_ |= 0x00000004; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Projection, com.mysql.cj.x.protobuf.MysqlxCrud.Projection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.ProjectionOrBuilder> projectionBuilder_; + + /** + * 
+       ** list of column projections that shall be returned 
+       *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public java.util.List getProjectionList() { + if (projectionBuilder_ == null) { + return java.util.Collections.unmodifiableList(projection_); + } else { + return projectionBuilder_.getMessageList(); + } + } + /** + * 
+       ** list of column projections that shall be returned 
+       *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public int getProjectionCount() { + if (projectionBuilder_ == null) { + return projection_.size(); + } else { + return projectionBuilder_.getCount(); + } + } + /** + * 
+       ** list of column projections that shall be returned 
+       *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Projection getProjection(int index) { + if (projectionBuilder_ == null) { + return projection_.get(index); + } else { + return projectionBuilder_.getMessage(index); + } + } + /** + * 
+       ** list of column projections that shall be returned 
+       *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public Builder setProjection( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Projection value) { + if (projectionBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureProjectionIsMutable(); + projection_.set(index, value); + onChanged(); + } else { + projectionBuilder_.setMessage(index, value); + } + return this; + } + /** + * 
+       ** list of column projections that shall be returned 
+       *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public Builder setProjection( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Projection.Builder builderForValue) { + if (projectionBuilder_ == null) { + ensureProjectionIsMutable(); + projection_.set(index, builderForValue.build()); + onChanged(); + } else { + projectionBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** list of column projections that shall be returned 
+       *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public Builder addProjection(com.mysql.cj.x.protobuf.MysqlxCrud.Projection value) { + if (projectionBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureProjectionIsMutable(); + projection_.add(value); + onChanged(); + } else { + projectionBuilder_.addMessage(value); + } + return this; + } + /** + * 
+       ** list of column projections that shall be returned 
+       *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public Builder addProjection( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Projection value) { + if (projectionBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureProjectionIsMutable(); + projection_.add(index, value); + onChanged(); + } else { + projectionBuilder_.addMessage(index, value); + } + return this; + } + /** + * 
+       ** list of column projections that shall be returned 
+       *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public Builder addProjection( + com.mysql.cj.x.protobuf.MysqlxCrud.Projection.Builder builderForValue) { + if (projectionBuilder_ == null) { + ensureProjectionIsMutable(); + projection_.add(builderForValue.build()); + onChanged(); + } else { + projectionBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * 
+       ** list of column projections that shall be returned 
+       *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public Builder addProjection( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Projection.Builder builderForValue) { + if (projectionBuilder_ == null) { + ensureProjectionIsMutable(); + projection_.add(index, builderForValue.build()); + onChanged(); + } else { + projectionBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** list of column projections that shall be returned 
+       *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public Builder addAllProjection( + java.lang.Iterable values) { + if (projectionBuilder_ == null) { + ensureProjectionIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, projection_); + onChanged(); + } else { + projectionBuilder_.addAllMessages(values); + } + return this; + } + /** + * 
+       ** list of column projections that shall be returned 
+       *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public Builder clearProjection() { + if (projectionBuilder_ == null) { + projection_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + onChanged(); + } else { + projectionBuilder_.clear(); + } + return this; + } + /** + * 
+       ** list of column projections that shall be returned 
+       *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public Builder removeProjection(int index) { + if (projectionBuilder_ == null) { + ensureProjectionIsMutable(); + projection_.remove(index); + onChanged(); + } else { + projectionBuilder_.remove(index); + } + return this; + } + /** + * 
+       ** list of column projections that shall be returned 
+       *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Projection.Builder getProjectionBuilder( + int index) { + return getProjectionFieldBuilder().getBuilder(index); + } + /** + * 
+       ** list of column projections that shall be returned 
+       *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.ProjectionOrBuilder getProjectionOrBuilder( + int index) { + if (projectionBuilder_ == null) { + return projection_.get(index); } else { + return projectionBuilder_.getMessageOrBuilder(index); + } + } + /** + * 
+       ** list of column projections that shall be returned 
+       *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public java.util.List + getProjectionOrBuilderList() { + if (projectionBuilder_ != null) { + return projectionBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(projection_); + } + } + /** + * 
+       ** list of column projections that shall be returned 
+       *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Projection.Builder addProjectionBuilder() { + return getProjectionFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxCrud.Projection.getDefaultInstance()); + } + /** + * 
+       ** list of column projections that shall be returned 
+       *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Projection.Builder addProjectionBuilder( + int index) { + return getProjectionFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxCrud.Projection.getDefaultInstance()); + } + /** + * 
+       ** list of column projections that shall be returned 
+       *
+ * + * repeated .Mysqlx.Crud.Projection projection = 4; + */ + public java.util.List + getProjectionBuilderList() { + return getProjectionFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Projection, com.mysql.cj.x.protobuf.MysqlxCrud.Projection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.ProjectionOrBuilder> + getProjectionFieldBuilder() { + if (projectionBuilder_ == null) { + projectionBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Projection, com.mysql.cj.x.protobuf.MysqlxCrud.Projection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.ProjectionOrBuilder>( + projection_, + ((bitField0_ & 0x00000004) != 0), + getParentForChildren(), + isClean()); + projection_ = null; + } + return projectionBuilder_; + } + + private java.util.List args_ = + java.util.Collections.emptyList(); + private void ensureArgsIsMutable() { + if (!((bitField0_ & 0x00000008) != 0)) { + args_ = new java.util.ArrayList(args_); + bitField0_ |= 0x00000008; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder> argsBuilder_; + + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public java.util.List getArgsList() { + if (argsBuilder_ == null) { + return java.util.Collections.unmodifiableList(args_); + } else { + return argsBuilder_.getMessageList(); + } + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public int getArgsCount() { + if (argsBuilder_ == null) { + return args_.size(); + } else { + return argsBuilder_.getCount(); + } + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getArgs(int index) { + if (argsBuilder_ == null) { + return args_.get(index); + } else { + return argsBuilder_.getMessage(index); + } + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public Builder setArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value) { + if (argsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgsIsMutable(); + args_.set(index, value); + onChanged(); + } else { + argsBuilder_.setMessage(index, value); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public Builder setArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder builderForValue) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.set(index, builderForValue.build()); + onChanged(); + } else { + argsBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public Builder addArgs(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value) { + if (argsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgsIsMutable(); + args_.add(value); + onChanged(); + } else { + argsBuilder_.addMessage(value); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public Builder addArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value) { + if (argsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgsIsMutable(); + args_.add(index, value); + onChanged(); + } else { + argsBuilder_.addMessage(index, value); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public Builder addArgs( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder builderForValue) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.add(builderForValue.build()); + onChanged(); + } else { + argsBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public Builder addArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder builderForValue) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.add(index, builderForValue.build()); + onChanged(); + } else { + argsBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public Builder addAllArgs( + java.lang.Iterable values) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, args_); + onChanged(); + } else { + argsBuilder_.addAllMessages(values); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public Builder clearArgs() { + if (argsBuilder_ == null) { + args_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000008); + onChanged(); + } else { + argsBuilder_.clear(); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public Builder removeArgs(int index) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.remove(index); + onChanged(); + } else { + argsBuilder_.remove(index); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder getArgsBuilder( + int index) { + return getArgsFieldBuilder().getBuilder(index); + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getArgsOrBuilder( + int index) { + if (argsBuilder_ == null) { + return args_.get(index); } else { + return argsBuilder_.getMessageOrBuilder(index); + } + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public java.util.List + getArgsOrBuilderList() { + if (argsBuilder_ != null) { + return argsBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(args_); + } + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder addArgsBuilder() { + return getArgsFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance()); + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder addArgsBuilder( + int index) { + return getArgsFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance()); + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 11; + */ + public java.util.List + getArgsBuilderList() { + return getArgsFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder> + getArgsFieldBuilder() { + if (argsBuilder_ == null) { + argsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder>( + args_, + ((bitField0_ & 0x00000008) != 0), + getParentForChildren(), + isClean()); + args_ = null; + } + return argsBuilder_; + } + + private com.mysql.cj.x.protobuf.MysqlxExpr.Expr criteria_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> criteriaBuilder_; + /** + * 
+       ** filter criteria 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 5; + * @return Whether the criteria field is set. + */ + public boolean hasCriteria() { + return ((bitField0_ & 0x00000010) != 0); + } + /** + * 
+       ** filter criteria 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 5; + * @return The criteria. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getCriteria() { + if (criteriaBuilder_ == null) { + return criteria_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : criteria_; + } else { + return criteriaBuilder_.getMessage(); + } + } + /** + * 
+       ** filter criteria 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 5; + */ + public Builder setCriteria(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (criteriaBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + criteria_ = value; + onChanged(); + } else { + criteriaBuilder_.setMessage(value); + } + bitField0_ |= 0x00000010; + return this; + } + /** + * 
+       ** filter criteria 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 5; + */ + public Builder setCriteria( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (criteriaBuilder_ == null) { + criteria_ = builderForValue.build(); + onChanged(); + } else { + criteriaBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000010; + return this; + } + /** + * 
+       ** filter criteria 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 5; + */ + public Builder mergeCriteria(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (criteriaBuilder_ == null) { + if (((bitField0_ & 0x00000010) != 0) && + criteria_ != null && + criteria_ != com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance()) { + criteria_ = + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.newBuilder(criteria_).mergeFrom(value).buildPartial(); + } else { + criteria_ = value; + } + onChanged(); + } else { + criteriaBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000010; + return this; + } + /** + * 
+       ** filter criteria 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 5; + */ + public Builder clearCriteria() { + if (criteriaBuilder_ == null) { + criteria_ = null; + onChanged(); + } else { + criteriaBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + /** + * 
+       ** filter criteria 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder getCriteriaBuilder() { + bitField0_ |= 0x00000010; + onChanged(); + return getCriteriaFieldBuilder().getBuilder(); + } + /** + * 
+       ** filter criteria 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getCriteriaOrBuilder() { + if (criteriaBuilder_ != null) { + return criteriaBuilder_.getMessageOrBuilder(); + } else { + return criteria_ == null ? + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : criteria_; + } + } + /** + * 
+       ** filter criteria 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 5; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> + getCriteriaFieldBuilder() { + if (criteriaBuilder_ == null) { + criteriaBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder>( + getCriteria(), + getParentForChildren(), + isClean()); + criteria_ = null; + } + return criteriaBuilder_; + } + + private com.mysql.cj.x.protobuf.MysqlxCrud.Limit limit_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Limit, com.mysql.cj.x.protobuf.MysqlxCrud.Limit.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.LimitOrBuilder> limitBuilder_; + /** + * 
+       ** numbers of rows that shall be skipped and returned
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 6; + * @return Whether the limit field is set. + */ + public boolean hasLimit() { + return ((bitField0_ & 0x00000020) != 0); + } + /** + * 
+       ** numbers of rows that shall be skipped and returned
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 6; + * @return The limit. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Limit getLimit() { + if (limitBuilder_ == null) { + return limit_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Limit.getDefaultInstance() : limit_; + } else { + return limitBuilder_.getMessage(); + } + } + /** + * 
+       ** numbers of rows that shall be skipped and returned
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 6; + */ + public Builder setLimit(com.mysql.cj.x.protobuf.MysqlxCrud.Limit value) { + if (limitBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + limit_ = value; + onChanged(); + } else { + limitBuilder_.setMessage(value); + } + bitField0_ |= 0x00000020; + return this; + } + /** + * 
+       ** numbers of rows that shall be skipped and returned
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 6; + */ + public Builder setLimit( + com.mysql.cj.x.protobuf.MysqlxCrud.Limit.Builder builderForValue) { + if (limitBuilder_ == null) { + limit_ = builderForValue.build(); + onChanged(); + } else { + limitBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000020; + return this; + } + /** + * 
+       ** numbers of rows that shall be skipped and returned
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 6; + */ + public Builder mergeLimit(com.mysql.cj.x.protobuf.MysqlxCrud.Limit value) { + if (limitBuilder_ == null) { + if (((bitField0_ & 0x00000020) != 0) && + limit_ != null && + limit_ != com.mysql.cj.x.protobuf.MysqlxCrud.Limit.getDefaultInstance()) { + limit_ = + com.mysql.cj.x.protobuf.MysqlxCrud.Limit.newBuilder(limit_).mergeFrom(value).buildPartial(); + } else { + limit_ = value; + } + onChanged(); + } else { + limitBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000020; + return this; + } + /** + * 
+       ** numbers of rows that shall be skipped and returned
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 6; + */ + public Builder clearLimit() { + if (limitBuilder_ == null) { + limit_ = null; + onChanged(); + } else { + limitBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000020); + return this; + } + /** + * 
+       ** numbers of rows that shall be skipped and returned
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Limit.Builder getLimitBuilder() { + bitField0_ |= 0x00000020; + onChanged(); + return getLimitFieldBuilder().getBuilder(); + } + /** + * 
+       ** numbers of rows that shall be skipped and returned
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitOrBuilder getLimitOrBuilder() { + if (limitBuilder_ != null) { + return limitBuilder_.getMessageOrBuilder(); + } else { + return limit_ == null ? + com.mysql.cj.x.protobuf.MysqlxCrud.Limit.getDefaultInstance() : limit_; + } + } + /** + * 
+       ** numbers of rows that shall be skipped and returned
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 6; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Limit, com.mysql.cj.x.protobuf.MysqlxCrud.Limit.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.LimitOrBuilder> + getLimitFieldBuilder() { + if (limitBuilder_ == null) { + limitBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Limit, com.mysql.cj.x.protobuf.MysqlxCrud.Limit.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.LimitOrBuilder>( + getLimit(), + getParentForChildren(), + isClean()); + limit_ = null; + } + return limitBuilder_; + } + + private java.util.List order_ = + java.util.Collections.emptyList(); + private void ensureOrderIsMutable() { + if (!((bitField0_ & 0x00000040) != 0)) { + order_ = new java.util.ArrayList(order_); + bitField0_ |= 0x00000040; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Order, com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.OrderOrBuilder> orderBuilder_; + + /** + * 
+       ** sort-order in which the rows/document shall be returned in 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public java.util.List getOrderList() { + if (orderBuilder_ == null) { + return java.util.Collections.unmodifiableList(order_); + } else { + return orderBuilder_.getMessageList(); + } + } + /** + * 
+       ** sort-order in which the rows/document shall be returned in 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public int getOrderCount() { + if (orderBuilder_ == null) { + return order_.size(); + } else { + return orderBuilder_.getCount(); + } + } + /** + * 
+       ** sort-order in which the rows/document shall be returned in 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Order getOrder(int index) { + if (orderBuilder_ == null) { + return order_.get(index); + } else { + return orderBuilder_.getMessage(index); + } + } + /** + * 
+       ** sort-order in which the rows/document shall be returned in 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public Builder setOrder( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Order value) { + if (orderBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureOrderIsMutable(); + order_.set(index, value); + onChanged(); + } else { + orderBuilder_.setMessage(index, value); + } + return this; + } + /** + * 
+       ** sort-order in which the rows/document shall be returned in 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public Builder setOrder( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder builderForValue) { + if (orderBuilder_ == null) { + ensureOrderIsMutable(); + order_.set(index, builderForValue.build()); + onChanged(); + } else { + orderBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** sort-order in which the rows/document shall be returned in 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public Builder addOrder(com.mysql.cj.x.protobuf.MysqlxCrud.Order value) { + if (orderBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureOrderIsMutable(); + order_.add(value); + onChanged(); + } else { + orderBuilder_.addMessage(value); + } + return this; + } + /** + * 
+       ** sort-order in which the rows/document shall be returned in 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public Builder addOrder( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Order value) { + if (orderBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureOrderIsMutable(); + order_.add(index, value); + onChanged(); + } else { + orderBuilder_.addMessage(index, value); + } + return this; + } + /** + * 
+       ** sort-order in which the rows/document shall be returned in 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public Builder addOrder( + com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder builderForValue) { + if (orderBuilder_ == null) { + ensureOrderIsMutable(); + order_.add(builderForValue.build()); + onChanged(); + } else { + orderBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * 
+       ** sort-order in which the rows/document shall be returned in 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public Builder addOrder( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder builderForValue) { + if (orderBuilder_ == null) { + ensureOrderIsMutable(); + order_.add(index, builderForValue.build()); + onChanged(); + } else { + orderBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** sort-order in which the rows/document shall be returned in 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public Builder addAllOrder( + java.lang.Iterable values) { + if (orderBuilder_ == null) { + ensureOrderIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, order_); + onChanged(); + } else { + orderBuilder_.addAllMessages(values); + } + return this; + } + /** + * 
+       ** sort-order in which the rows/document shall be returned in 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public Builder clearOrder() { + if (orderBuilder_ == null) { + order_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000040); + onChanged(); + } else { + orderBuilder_.clear(); + } + return this; + } + /** + * 
+       ** sort-order in which the rows/document shall be returned in 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public Builder removeOrder(int index) { + if (orderBuilder_ == null) { + ensureOrderIsMutable(); + order_.remove(index); + onChanged(); + } else { + orderBuilder_.remove(index); + } + return this; + } + /** + * 
+       ** sort-order in which the rows/document shall be returned in 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder getOrderBuilder( + int index) { + return getOrderFieldBuilder().getBuilder(index); + } + /** + * 
+       ** sort-order in which the rows/document shall be returned in 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.OrderOrBuilder getOrderOrBuilder( + int index) { + if (orderBuilder_ == null) { + return order_.get(index); } else { + return orderBuilder_.getMessageOrBuilder(index); + } + } + /** + * 
+       ** sort-order in which the rows/document shall be returned in 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public java.util.List + getOrderOrBuilderList() { + if (orderBuilder_ != null) { + return orderBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(order_); + } + } + /** + * 
+       ** sort-order in which the rows/document shall be returned in 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder addOrderBuilder() { + return getOrderFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxCrud.Order.getDefaultInstance()); + } + /** + * 
+       ** sort-order in which the rows/document shall be returned in 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder addOrderBuilder( + int index) { + return getOrderFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxCrud.Order.getDefaultInstance()); + } + /** + * 
+       ** sort-order in which the rows/document shall be returned in 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 7; + */ + public java.util.List + getOrderBuilderList() { + return getOrderFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Order, com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.OrderOrBuilder> + getOrderFieldBuilder() { + if (orderBuilder_ == null) { + orderBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Order, com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.OrderOrBuilder>( + order_, + ((bitField0_ & 0x00000040) != 0), + getParentForChildren(), + isClean()); + order_ = null; + } + return orderBuilder_; + } + + private java.util.List grouping_ = + java.util.Collections.emptyList(); + private void ensureGroupingIsMutable() { + if (!((bitField0_ & 0x00000080) != 0)) { + grouping_ = new java.util.ArrayList(grouping_); + bitField0_ |= 0x00000080; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> groupingBuilder_; + + /** + * 
+       ** column expression list for aggregation (GROUP BY) 
+       *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public java.util.List getGroupingList() { + if (groupingBuilder_ == null) { + return java.util.Collections.unmodifiableList(grouping_); + } else { + return groupingBuilder_.getMessageList(); + } + } + /** + * 
+       ** column expression list for aggregation (GROUP BY) 
+       *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public int getGroupingCount() { + if (groupingBuilder_ == null) { + return grouping_.size(); + } else { + return groupingBuilder_.getCount(); + } + } + /** + * 
+       ** column expression list for aggregation (GROUP BY) 
+       *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getGrouping(int index) { + if (groupingBuilder_ == null) { + return grouping_.get(index); + } else { + return groupingBuilder_.getMessage(index); + } + } + /** + * 
+       ** column expression list for aggregation (GROUP BY) 
+       *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public Builder setGrouping( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (groupingBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureGroupingIsMutable(); + grouping_.set(index, value); + onChanged(); + } else { + groupingBuilder_.setMessage(index, value); + } + return this; + } + /** + * 
+       ** column expression list for aggregation (GROUP BY) 
+       *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public Builder setGrouping( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (groupingBuilder_ == null) { + ensureGroupingIsMutable(); + grouping_.set(index, builderForValue.build()); + onChanged(); + } else { + groupingBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** column expression list for aggregation (GROUP BY) 
+       *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public Builder addGrouping(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (groupingBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureGroupingIsMutable(); + grouping_.add(value); + onChanged(); + } else { + groupingBuilder_.addMessage(value); + } + return this; + } + /** + * 
+       ** column expression list for aggregation (GROUP BY) 
+       *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public Builder addGrouping( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (groupingBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureGroupingIsMutable(); + grouping_.add(index, value); + onChanged(); + } else { + groupingBuilder_.addMessage(index, value); + } + return this; + } + /** + * 
+       ** column expression list for aggregation (GROUP BY) 
+       *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public Builder addGrouping( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (groupingBuilder_ == null) { + ensureGroupingIsMutable(); + grouping_.add(builderForValue.build()); + onChanged(); + } else { + groupingBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * 
+       ** column expression list for aggregation (GROUP BY) 
+       *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public Builder addGrouping( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (groupingBuilder_ == null) { + ensureGroupingIsMutable(); + grouping_.add(index, builderForValue.build()); + onChanged(); + } else { + groupingBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** column expression list for aggregation (GROUP BY) 
+       *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public Builder addAllGrouping( + java.lang.Iterable values) { + if (groupingBuilder_ == null) { + ensureGroupingIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, grouping_); + onChanged(); + } else { + groupingBuilder_.addAllMessages(values); + } + return this; + } + /** + * 
+       ** column expression list for aggregation (GROUP BY) 
+       *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public Builder clearGrouping() { + if (groupingBuilder_ == null) { + grouping_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000080); + onChanged(); + } else { + groupingBuilder_.clear(); + } + return this; + } + /** + * 
+       ** column expression list for aggregation (GROUP BY) 
+       *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public Builder removeGrouping(int index) { + if (groupingBuilder_ == null) { + ensureGroupingIsMutable(); + grouping_.remove(index); + onChanged(); + } else { + groupingBuilder_.remove(index); + } + return this; + } + /** + * 
+       ** column expression list for aggregation (GROUP BY) 
+       *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder getGroupingBuilder( + int index) { + return getGroupingFieldBuilder().getBuilder(index); + } + /** + * 
+       ** column expression list for aggregation (GROUP BY) 
+       *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getGroupingOrBuilder( + int index) { + if (groupingBuilder_ == null) { + return grouping_.get(index); } else { + return groupingBuilder_.getMessageOrBuilder(index); + } + } + /** + * 
+       ** column expression list for aggregation (GROUP BY) 
+       *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public java.util.List + getGroupingOrBuilderList() { + if (groupingBuilder_ != null) { + return groupingBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(grouping_); + } + } + /** + * 
+       ** column expression list for aggregation (GROUP BY) 
+       *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder addGroupingBuilder() { + return getGroupingFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance()); + } + /** + * 
+       ** column expression list for aggregation (GROUP BY) 
+       *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder addGroupingBuilder( + int index) { + return getGroupingFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance()); + } + /** + * 
+       ** column expression list for aggregation (GROUP BY) 
+       *
+ * + * repeated .Mysqlx.Expr.Expr grouping = 8; + */ + public java.util.List + getGroupingBuilderList() { + return getGroupingFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> + getGroupingFieldBuilder() { + if (groupingBuilder_ == null) { + groupingBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder>( + grouping_, + ((bitField0_ & 0x00000080) != 0), + getParentForChildren(), + isClean()); + grouping_ = null; + } + return groupingBuilder_; + } + + private com.mysql.cj.x.protobuf.MysqlxExpr.Expr groupingCriteria_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> groupingCriteriaBuilder_; + /** + * 
+       ** filter criteria for aggregated groups 
+       *
+ * + * optional .Mysqlx.Expr.Expr grouping_criteria = 9; + * @return Whether the groupingCriteria field is set. + */ + public boolean hasGroupingCriteria() { + return ((bitField0_ & 0x00000100) != 0); + } + /** + * 
+       ** filter criteria for aggregated groups 
+       *
+ * + * optional .Mysqlx.Expr.Expr grouping_criteria = 9; + * @return The groupingCriteria. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getGroupingCriteria() { + if (groupingCriteriaBuilder_ == null) { + return groupingCriteria_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : groupingCriteria_; + } else { + return groupingCriteriaBuilder_.getMessage(); + } + } + /** + * 
+       ** filter criteria for aggregated groups 
+       *
+ * + * optional .Mysqlx.Expr.Expr grouping_criteria = 9; + */ + public Builder setGroupingCriteria(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (groupingCriteriaBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + groupingCriteria_ = value; + onChanged(); + } else { + groupingCriteriaBuilder_.setMessage(value); + } + bitField0_ |= 0x00000100; + return this; + } + /** + * 
+       ** filter criteria for aggregated groups 
+       *
+ * + * optional .Mysqlx.Expr.Expr grouping_criteria = 9; + */ + public Builder setGroupingCriteria( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (groupingCriteriaBuilder_ == null) { + groupingCriteria_ = builderForValue.build(); + onChanged(); + } else { + groupingCriteriaBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000100; + return this; + } + /** + * 
+       ** filter criteria for aggregated groups 
+       *
+ * + * optional .Mysqlx.Expr.Expr grouping_criteria = 9; + */ + public Builder mergeGroupingCriteria(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (groupingCriteriaBuilder_ == null) { + if (((bitField0_ & 0x00000100) != 0) && + groupingCriteria_ != null && + groupingCriteria_ != com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance()) { + groupingCriteria_ = + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.newBuilder(groupingCriteria_).mergeFrom(value).buildPartial(); + } else { + groupingCriteria_ = value; + } + onChanged(); + } else { + groupingCriteriaBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000100; + return this; + } + /** + * 
+       ** filter criteria for aggregated groups 
+       *
+ * + * optional .Mysqlx.Expr.Expr grouping_criteria = 9; + */ + public Builder clearGroupingCriteria() { + if (groupingCriteriaBuilder_ == null) { + groupingCriteria_ = null; + onChanged(); + } else { + groupingCriteriaBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000100); + return this; + } + /** + * 
+       ** filter criteria for aggregated groups 
+       *
+ * + * optional .Mysqlx.Expr.Expr grouping_criteria = 9; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder getGroupingCriteriaBuilder() { + bitField0_ |= 0x00000100; + onChanged(); + return getGroupingCriteriaFieldBuilder().getBuilder(); + } + /** + * 
+       ** filter criteria for aggregated groups 
+       *
+ * + * optional .Mysqlx.Expr.Expr grouping_criteria = 9; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getGroupingCriteriaOrBuilder() { + if (groupingCriteriaBuilder_ != null) { + return groupingCriteriaBuilder_.getMessageOrBuilder(); + } else { + return groupingCriteria_ == null ? + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : groupingCriteria_; + } + } + /** + * 
+       ** filter criteria for aggregated groups 
+       *
+ * + * optional .Mysqlx.Expr.Expr grouping_criteria = 9; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> + getGroupingCriteriaFieldBuilder() { + if (groupingCriteriaBuilder_ == null) { + groupingCriteriaBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder>( + getGroupingCriteria(), + getParentForChildren(), + isClean()); + groupingCriteria_ = null; + } + return groupingCriteriaBuilder_; + } + + private int locking_ = 1; + /** + * 
+       ** perform row locking on matches 
+       *
+ * + * optional .Mysqlx.Crud.Find.RowLock locking = 12; + * @return Whether the locking field is set. + */ + public boolean hasLocking() { + return ((bitField0_ & 0x00000200) != 0); + } + /** + * 
+       ** perform row locking on matches 
+       *
+ * + * optional .Mysqlx.Crud.Find.RowLock locking = 12; + * @return The locking. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLock getLocking() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLock result = com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLock.valueOf(locking_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLock.SHARED_LOCK : result; + } + /** + * 
+       ** perform row locking on matches 
+       *
+ * + * optional .Mysqlx.Crud.Find.RowLock locking = 12; + * @param value The locking to set. + * @return This builder for chaining. + */ + public Builder setLocking(com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLock value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000200; + locking_ = value.getNumber(); + onChanged(); + return this; + } + /** + * 
+       ** perform row locking on matches 
+       *
+ * + * optional .Mysqlx.Crud.Find.RowLock locking = 12; + * @return This builder for chaining. + */ + public Builder clearLocking() { + bitField0_ = (bitField0_ & ~0x00000200); + locking_ = 1; + onChanged(); + return this; + } + + private int lockingOptions_ = 1; + /** + * 
+       ** additional options how to handle locked rows 
+       *
+ * + * optional .Mysqlx.Crud.Find.RowLockOptions locking_options = 13; + * @return Whether the lockingOptions field is set. + */ + public boolean hasLockingOptions() { + return ((bitField0_ & 0x00000400) != 0); + } + /** + * 
+       ** additional options how to handle locked rows 
+       *
+ * + * optional .Mysqlx.Crud.Find.RowLockOptions locking_options = 13; + * @return The lockingOptions. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLockOptions getLockingOptions() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLockOptions result = com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLockOptions.valueOf(lockingOptions_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLockOptions.NOWAIT : result; + } + /** + * 
+       ** additional options how to handle locked rows 
+       *
+ * + * optional .Mysqlx.Crud.Find.RowLockOptions locking_options = 13; + * @param value The lockingOptions to set. + * @return This builder for chaining. + */ + public Builder setLockingOptions(com.mysql.cj.x.protobuf.MysqlxCrud.Find.RowLockOptions value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000400; + lockingOptions_ = value.getNumber(); + onChanged(); + return this; + } + /** + * 
+       ** additional options how to handle locked rows 
+       *
+ * + * optional .Mysqlx.Crud.Find.RowLockOptions locking_options = 13; + * @return This builder for chaining. + */ + public Builder clearLockingOptions() { + bitField0_ = (bitField0_ & ~0x00000400); + lockingOptions_ = 1; + onChanged(); + return this; + } + + private com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr limitExpr_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr, com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.LimitExprOrBuilder> limitExprBuilder_; + /** + * 
+       ** numbers of rows that shall be skipped and returned
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 14; + * @return Whether the limitExpr field is set. + */ + public boolean hasLimitExpr() { + return ((bitField0_ & 0x00000800) != 0); + } + /** + * 
+       ** numbers of rows that shall be skipped and returned
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 14; + * @return The limitExpr. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr getLimitExpr() { + if (limitExprBuilder_ == null) { + return limitExpr_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.getDefaultInstance() : limitExpr_; + } else { + return limitExprBuilder_.getMessage(); + } + } + /** + * 
+       ** numbers of rows that shall be skipped and returned
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 14; + */ + public Builder setLimitExpr(com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr value) { + if (limitExprBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + limitExpr_ = value; + onChanged(); + } else { + limitExprBuilder_.setMessage(value); + } + bitField0_ |= 0x00000800; + return this; + } + /** + * 
+       ** numbers of rows that shall be skipped and returned
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 14; + */ + public Builder setLimitExpr( + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.Builder builderForValue) { + if (limitExprBuilder_ == null) { + limitExpr_ = builderForValue.build(); + onChanged(); + } else { + limitExprBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000800; + return this; + } + /** + * 
+       ** numbers of rows that shall be skipped and returned
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 14; + */ + public Builder mergeLimitExpr(com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr value) { + if (limitExprBuilder_ == null) { + if (((bitField0_ & 0x00000800) != 0) && + limitExpr_ != null && + limitExpr_ != com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.getDefaultInstance()) { + limitExpr_ = + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.newBuilder(limitExpr_).mergeFrom(value).buildPartial(); + } else { + limitExpr_ = value; + } + onChanged(); + } else { + limitExprBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000800; + return this; + } + /** + * 
+       ** numbers of rows that shall be skipped and returned
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 14; + */ + public Builder clearLimitExpr() { + if (limitExprBuilder_ == null) { + limitExpr_ = null; + onChanged(); + } else { + limitExprBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000800); + return this; + } + /** + * 
+       ** numbers of rows that shall be skipped and returned
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 14; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.Builder getLimitExprBuilder() { + bitField0_ |= 0x00000800; + onChanged(); + return getLimitExprFieldBuilder().getBuilder(); + } + /** + * 
+       ** numbers of rows that shall be skipped and returned
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 14; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitExprOrBuilder getLimitExprOrBuilder() { + if (limitExprBuilder_ != null) { + return limitExprBuilder_.getMessageOrBuilder(); + } else { + return limitExpr_ == null ? + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.getDefaultInstance() : limitExpr_; + } + } + /** + * 
+       ** numbers of rows that shall be skipped and returned
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 14; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr, com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.LimitExprOrBuilder> + getLimitExprFieldBuilder() { + if (limitExprBuilder_ == null) { + limitExprBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr, com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.LimitExprOrBuilder>( + getLimitExpr(), + getParentForChildren(), + isClean()); + limitExpr_ = null; + } + return limitExprBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Crud.Find) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Crud.Find) + private static final com.mysql.cj.x.protobuf.MysqlxCrud.Find DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxCrud.Find(); + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.Find getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Find parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Find(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Find getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface InsertOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Crud.Insert) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** collection to insert into 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return Whether the collection field is set. + */ + boolean hasCollection(); + /** + * 
+     ** collection to insert into 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return The collection. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Collection getCollection(); + /** + * 
+     ** collection to insert into 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder getCollectionOrBuilder(); + + /** + * 
+     ** data model that the operations refer to 
+     *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 2; + * @return Whether the dataModel field is set. + */ + boolean hasDataModel(); + /** + * 
+     ** data model that the operations refer to 
+     *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 2; + * @return The dataModel. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.DataModel getDataModel(); + + /** + * 
+     ** name of the columns to insert data into
+     *(empty if data_model is DOCUMENT) 
+     *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + java.util.List + getProjectionList(); + /** + * 
+     ** name of the columns to insert data into
+     *(empty if data_model is DOCUMENT) 
+     *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Column getProjection(int index); + /** + * 
+     ** name of the columns to insert data into
+     *(empty if data_model is DOCUMENT) 
+     *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + int getProjectionCount(); + /** + * 
+     ** name of the columns to insert data into
+     *(empty if data_model is DOCUMENT) 
+     *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + java.util.List + getProjectionOrBuilderList(); + /** + * 
+     ** name of the columns to insert data into
+     *(empty if data_model is DOCUMENT) 
+     *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.ColumnOrBuilder getProjectionOrBuilder( + int index); + + /** + * 
+     ** set of rows to insert into the collection/table (a single expression
+     *with a JSON document literal or an OBJECT expression) 
+     *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + java.util.List + getRowList(); + /** + * 
+     ** set of rows to insert into the collection/table (a single expression
+     *with a JSON document literal or an OBJECT expression) 
+     *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow getRow(int index); + /** + * 
+     ** set of rows to insert into the collection/table (a single expression
+     *with a JSON document literal or an OBJECT expression) 
+     *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + int getRowCount(); + /** + * 
+     ** set of rows to insert into the collection/table (a single expression
+     *with a JSON document literal or an OBJECT expression) 
+     *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + java.util.List + getRowOrBuilderList(); + /** + * 
+     ** set of rows to insert into the collection/table (a single expression
+     *with a JSON document literal or an OBJECT expression) 
+     *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRowOrBuilder getRowOrBuilder( + int index); + + /** + * 
+     ** values for parameters used in row expressions 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + java.util.List + getArgsList(); + /** + * 
+     ** values for parameters used in row expressions 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getArgs(int index); + /** + * 
+     ** values for parameters used in row expressions 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + int getArgsCount(); + /** + * 
+     ** values for parameters used in row expressions 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + java.util.List + getArgsOrBuilderList(); + /** + * 
+     ** values for parameters used in row expressions 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getArgsOrBuilder( + int index); + + /** + * 
+     ** true if this should be treated as an Upsert
+     *(that is, update on duplicate key) 
+     *
+ * + * optional bool upsert = 6 [default = false]; + * @return Whether the upsert field is set. + */ + boolean hasUpsert(); + /** + * 
+     ** true if this should be treated as an Upsert
+     *(that is, update on duplicate key) 
+     *
+ * + * optional bool upsert = 6 [default = false]; + * @return The upsert. + */ + boolean getUpsert(); + } + /** + * 
+   **
+   *Insert documents/rows into a collection/table
+   *@returns @ref Mysqlx::Resultset
+   *
+ * + * Protobuf type {@code Mysqlx.Crud.Insert} + */ + public static final class Insert extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Crud.Insert) + InsertOrBuilder { + private static final long serialVersionUID = 0L; + // Use Insert.newBuilder() to construct. + private Insert(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Insert() { + dataModel_ = 1; + projection_ = java.util.Collections.emptyList(); + row_ = java.util.Collections.emptyList(); + args_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Insert(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Insert( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) != 0)) { + subBuilder = collection_.toBuilder(); + } + collection_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Collection.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(collection_); + collection_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 16: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.DataModel value = com.mysql.cj.x.protobuf.MysqlxCrud.DataModel.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(2, rawValue); + } else { + bitField0_ |= 0x00000002; + dataModel_ = rawValue; + } + break; + } + case 26: { + if (!((mutable_bitField0_ & 0x00000004) != 0)) { + projection_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000004; + } + projection_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Column.PARSER, extensionRegistry)); + break; + } + case 34: { + if (!((mutable_bitField0_ & 0x00000008) != 0)) { + row_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000008; + } + row_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow.PARSER, extensionRegistry)); + break; + } + case 42: { + if (!((mutable_bitField0_ & 0x00000010) != 0)) { + args_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000010; + } + args_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.PARSER, extensionRegistry)); + break; + } + case 48: { + bitField0_ |= 0x00000004; + upsert_ = input.readBool(); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000004) != 0)) { + projection_ = java.util.Collections.unmodifiableList(projection_); + } + if (((mutable_bitField0_ & 0x00000008) != 0)) { + row_ = java.util.Collections.unmodifiableList(row_); + } + if (((mutable_bitField0_ & 0x00000010) != 0)) { + args_ = java.util.Collections.unmodifiableList(args_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Insert_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Insert_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.Insert.class, com.mysql.cj.x.protobuf.MysqlxCrud.Insert.Builder.class); + } + + public interface TypedRowOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Crud.Insert.TypedRow) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + java.util.List + getFieldList(); + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Expr getField(int index); + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + int getFieldCount(); + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + java.util.List + getFieldOrBuilderList(); + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getFieldOrBuilder( + int index); + } + /** + * 
+     ** set of fields to insert as a one row 
+     *
+ * + * Protobuf type {@code Mysqlx.Crud.Insert.TypedRow} + */ + public static final class TypedRow extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Crud.Insert.TypedRow) + TypedRowOrBuilder { + private static final long serialVersionUID = 0L; + // Use TypedRow.newBuilder() to construct. + private TypedRow(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private TypedRow() { + field_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new TypedRow(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private TypedRow( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + if (!((mutable_bitField0_ & 0x00000001) != 0)) { + field_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + field_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.Expr.PARSER, extensionRegistry)); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000001) != 0)) { + field_ = java.util.Collections.unmodifiableList(field_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Insert_TypedRow_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Insert_TypedRow_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow.class, com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow.Builder.class); + } + + public static final int FIELD_FIELD_NUMBER = 1; + private java.util.List field_; + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public java.util.List getFieldList() { + return field_; + } + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public java.util.List + getFieldOrBuilderList() { + return field_; + } + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public int getFieldCount() { + return field_.size(); + } + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getField(int index) { + return field_.get(index); + } + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getFieldOrBuilder( + int index) { + return field_.get(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + for (int i = 0; i < getFieldCount(); i++) { + if (!getField(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < field_.size(); i++) { + output.writeMessage(1, field_.get(i)); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < field_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, field_.get(i)); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow other = (com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow) obj; + + if (!getFieldList() + .equals(other.getFieldList())) return false; + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getFieldCount() > 0) { + hash = (37 * hash) + FIELD_FIELD_NUMBER; + hash = (53 * hash) + getFieldList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+       ** set of fields to insert as a one row 
+       *
+ * + * Protobuf type {@code Mysqlx.Crud.Insert.TypedRow} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Crud.Insert.TypedRow) + com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRowOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Insert_TypedRow_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Insert_TypedRow_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow.class, com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getFieldFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + if (fieldBuilder_ == null) { + field_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + } else { + fieldBuilder_.clear(); + } + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Insert_TypedRow_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow build() { + com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow buildPartial() { + com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow result = new com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow(this); + int from_bitField0_ = bitField0_; + if (fieldBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0)) { + field_ = java.util.Collections.unmodifiableList(field_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.field_ = field_; + } else { + result.field_ = fieldBuilder_.build(); + } + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow other) { + if (other == com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow.getDefaultInstance()) return this; + if (fieldBuilder_ == null) { + if (!other.field_.isEmpty()) { + if (field_.isEmpty()) { + field_ = other.field_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureFieldIsMutable(); + field_.addAll(other.field_); + } + onChanged(); + } + } else { + if (!other.field_.isEmpty()) { + if (fieldBuilder_.isEmpty()) { + fieldBuilder_.dispose(); + fieldBuilder_ = null; + field_ = other.field_; + bitField0_ = (bitField0_ & ~0x00000001); + fieldBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getFieldFieldBuilder() : null; + } else { + fieldBuilder_.addAllMessages(other.field_); + } + } + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + for (int i = 0; i < getFieldCount(); i++) { + if (!getField(i).isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List field_ = + java.util.Collections.emptyList(); + private void ensureFieldIsMutable() { + if (!((bitField0_ & 0x00000001) != 0)) { + field_ = new java.util.ArrayList(field_); + bitField0_ |= 0x00000001; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> fieldBuilder_; + + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public java.util.List getFieldList() { + if (fieldBuilder_ == null) { + return java.util.Collections.unmodifiableList(field_); + } else { + return fieldBuilder_.getMessageList(); + } + } + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public int getFieldCount() { + if (fieldBuilder_ == null) { + return field_.size(); + } else { + return fieldBuilder_.getCount(); + } + } + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getField(int index) { + if (fieldBuilder_ == null) { + return field_.get(index); + } else { + return fieldBuilder_.getMessage(index); + } + } + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public Builder setField( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (fieldBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureFieldIsMutable(); + field_.set(index, value); + onChanged(); + } else { + fieldBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public Builder setField( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (fieldBuilder_ == null) { + ensureFieldIsMutable(); + field_.set(index, builderForValue.build()); + onChanged(); + } else { + fieldBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public Builder addField(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (fieldBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureFieldIsMutable(); + field_.add(value); + onChanged(); + } else { + fieldBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public Builder addField( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (fieldBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureFieldIsMutable(); + field_.add(index, value); + onChanged(); + } else { + fieldBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public Builder addField( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (fieldBuilder_ == null) { + ensureFieldIsMutable(); + field_.add(builderForValue.build()); + onChanged(); + } else { + fieldBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public Builder addField( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (fieldBuilder_ == null) { + ensureFieldIsMutable(); + field_.add(index, builderForValue.build()); + onChanged(); + } else { + fieldBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public Builder addAllField( + java.lang.Iterable values) { + if (fieldBuilder_ == null) { + ensureFieldIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, field_); + onChanged(); + } else { + fieldBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public Builder clearField() { + if (fieldBuilder_ == null) { + field_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + } else { + fieldBuilder_.clear(); + } + return this; + } + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public Builder removeField(int index) { + if (fieldBuilder_ == null) { + ensureFieldIsMutable(); + field_.remove(index); + onChanged(); + } else { + fieldBuilder_.remove(index); + } + return this; + } + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder getFieldBuilder( + int index) { + return getFieldFieldBuilder().getBuilder(index); + } + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getFieldOrBuilder( + int index) { + if (fieldBuilder_ == null) { + return field_.get(index); } else { + return fieldBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public java.util.List + getFieldOrBuilderList() { + if (fieldBuilder_ != null) { + return fieldBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(field_); + } + } + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder addFieldBuilder() { + return getFieldFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance()); + } + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder addFieldBuilder( + int index) { + return getFieldFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance()); + } + /** + * repeated .Mysqlx.Expr.Expr field = 1; + */ + public java.util.List + getFieldBuilderList() { + return getFieldFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> + getFieldFieldBuilder() { + if (fieldBuilder_ == null) { + fieldBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder>( + field_, + ((bitField0_ & 0x00000001) != 0), + getParentForChildren(), + isClean()); + field_ = null; + } + return fieldBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Crud.Insert.TypedRow) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Crud.Insert.TypedRow) + private static final com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow(); + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public TypedRow parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new TypedRow(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private int bitField0_; + public static final int COLLECTION_FIELD_NUMBER = 1; + private com.mysql.cj.x.protobuf.MysqlxCrud.Collection collection_; + /** + * 
+     ** collection to insert into 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return Whether the collection field is set. + */ + public boolean hasCollection() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** collection to insert into 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return The collection. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection getCollection() { + return collection_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } + /** + * 
+     ** collection to insert into 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder getCollectionOrBuilder() { + return collection_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } + + public static final int DATA_MODEL_FIELD_NUMBER = 2; + private int dataModel_; + /** + * 
+     ** data model that the operations refer to 
+     *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 2; + * @return Whether the dataModel field is set. + */ + public boolean hasDataModel() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** data model that the operations refer to 
+     *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 2; + * @return The dataModel. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.DataModel getDataModel() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.DataModel result = com.mysql.cj.x.protobuf.MysqlxCrud.DataModel.valueOf(dataModel_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.DataModel.DOCUMENT : result; + } + + public static final int PROJECTION_FIELD_NUMBER = 3; + private java.util.List projection_; + /** + * 
+     ** name of the columns to insert data into
+     *(empty if data_model is DOCUMENT) 
+     *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public java.util.List getProjectionList() { + return projection_; + } + /** + * 
+     ** name of the columns to insert data into
+     *(empty if data_model is DOCUMENT) 
+     *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public java.util.List + getProjectionOrBuilderList() { + return projection_; + } + /** + * 
+     ** name of the columns to insert data into
+     *(empty if data_model is DOCUMENT) 
+     *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public int getProjectionCount() { + return projection_.size(); + } + /** + * 
+     ** name of the columns to insert data into
+     *(empty if data_model is DOCUMENT) 
+     *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Column getProjection(int index) { + return projection_.get(index); + } + /** + * 
+     ** name of the columns to insert data into
+     *(empty if data_model is DOCUMENT) 
+     *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.ColumnOrBuilder getProjectionOrBuilder( + int index) { + return projection_.get(index); + } + + public static final int ROW_FIELD_NUMBER = 4; + private java.util.List row_; + /** + * 
+     ** set of rows to insert into the collection/table (a single expression
+     *with a JSON document literal or an OBJECT expression) 
+     *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public java.util.List getRowList() { + return row_; + } + /** + * 
+     ** set of rows to insert into the collection/table (a single expression
+     *with a JSON document literal or an OBJECT expression) 
+     *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public java.util.List + getRowOrBuilderList() { + return row_; + } + /** + * 
+     ** set of rows to insert into the collection/table (a single expression
+     *with a JSON document literal or an OBJECT expression) 
+     *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public int getRowCount() { + return row_.size(); + } + /** + * 
+     ** set of rows to insert into the collection/table (a single expression
+     *with a JSON document literal or an OBJECT expression) 
+     *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow getRow(int index) { + return row_.get(index); + } + /** + * 
+     ** set of rows to insert into the collection/table (a single expression
+     *with a JSON document literal or an OBJECT expression) 
+     *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRowOrBuilder getRowOrBuilder( + int index) { + return row_.get(index); + } + + public static final int ARGS_FIELD_NUMBER = 5; + private java.util.List args_; + /** + * 
+     ** values for parameters used in row expressions 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public java.util.List getArgsList() { + return args_; + } + /** + * 
+     ** values for parameters used in row expressions 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public java.util.List + getArgsOrBuilderList() { + return args_; + } + /** + * 
+     ** values for parameters used in row expressions 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public int getArgsCount() { + return args_.size(); + } + /** + * 
+     ** values for parameters used in row expressions 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getArgs(int index) { + return args_.get(index); + } + /** + * 
+     ** values for parameters used in row expressions 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getArgsOrBuilder( + int index) { + return args_.get(index); + } + + public static final int UPSERT_FIELD_NUMBER = 6; + private boolean upsert_; + /** + * 
+     ** true if this should be treated as an Upsert
+     *(that is, update on duplicate key) 
+     *
+ * + * optional bool upsert = 6 [default = false]; + * @return Whether the upsert field is set. + */ + public boolean hasUpsert() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+     ** true if this should be treated as an Upsert
+     *(that is, update on duplicate key) 
+     *
+ * + * optional bool upsert = 6 [default = false]; + * @return The upsert. + */ + public boolean getUpsert() { + return upsert_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasCollection()) { + memoizedIsInitialized = 0; + return false; + } + if (!getCollection().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + for (int i = 0; i < getProjectionCount(); i++) { + if (!getProjection(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + for (int i = 0; i < getRowCount(); i++) { + if (!getRow(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + for (int i = 0; i < getArgsCount(); i++) { + if (!getArgs(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeMessage(1, getCollection()); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeEnum(2, dataModel_); + } + for (int i = 0; i < projection_.size(); i++) { + output.writeMessage(3, projection_.get(i)); + } + for (int i = 0; i < row_.size(); i++) { + output.writeMessage(4, row_.get(i)); + } + for (int i = 0; i < args_.size(); i++) { + output.writeMessage(5, args_.get(i)); + } + if (((bitField0_ & 0x00000004) != 0)) { + output.writeBool(6, upsert_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, getCollection()); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(2, dataModel_); + } + for (int i = 0; i < projection_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, projection_.get(i)); + } + for (int i = 0; i < row_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, row_.get(i)); + } + for (int i = 0; i < args_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(5, args_.get(i)); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(6, upsert_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxCrud.Insert)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxCrud.Insert other = (com.mysql.cj.x.protobuf.MysqlxCrud.Insert) obj; + + if (hasCollection() != other.hasCollection()) return false; + if (hasCollection()) { + if (!getCollection() + .equals(other.getCollection())) return false; + } + if (hasDataModel() != other.hasDataModel()) return false; + if (hasDataModel()) { + if (dataModel_ != other.dataModel_) return false; + } + if (!getProjectionList() + .equals(other.getProjectionList())) return false; + if (!getRowList() + .equals(other.getRowList())) return false; + if (!getArgsList() + .equals(other.getArgsList())) return false; + if (hasUpsert() != other.hasUpsert()) return false; + if (hasUpsert()) { + if (getUpsert() + != other.getUpsert()) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasCollection()) { + hash = (37 * hash) + COLLECTION_FIELD_NUMBER; + hash = (53 * hash) + getCollection().hashCode(); + } + if (hasDataModel()) { + hash = (37 * hash) + DATA_MODEL_FIELD_NUMBER; + hash = (53 * hash) + dataModel_; + } + if (getProjectionCount() > 0) { + hash = (37 * hash) + PROJECTION_FIELD_NUMBER; + hash = (53 * hash) + getProjectionList().hashCode(); + } + if (getRowCount() > 0) { + hash = (37 * hash) + ROW_FIELD_NUMBER; + hash = (53 * hash) + getRowList().hashCode(); + } + if (getArgsCount() > 0) { + hash = (37 * hash) + ARGS_FIELD_NUMBER; + hash = (53 * hash) + getArgsList().hashCode(); + } + if (hasUpsert()) { + hash = (37 * hash) + UPSERT_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getUpsert()); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxCrud.Insert prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Insert documents/rows into a collection/table
+     *@returns @ref Mysqlx::Resultset
+     *
+ * + * Protobuf type {@code Mysqlx.Crud.Insert} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Crud.Insert) + com.mysql.cj.x.protobuf.MysqlxCrud.InsertOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Insert_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Insert_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.Insert.class, com.mysql.cj.x.protobuf.MysqlxCrud.Insert.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxCrud.Insert.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getCollectionFieldBuilder(); + getProjectionFieldBuilder(); + getRowFieldBuilder(); + getArgsFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + if (collectionBuilder_ == null) { + collection_ = null; + } else { + collectionBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + dataModel_ = 1; + bitField0_ = (bitField0_ & ~0x00000002); + if (projectionBuilder_ == null) { + projection_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + } else { + projectionBuilder_.clear(); + } + if (rowBuilder_ == null) { + row_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000008); + } else { + rowBuilder_.clear(); + } + if (argsBuilder_ == null) { + args_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000010); + } else { + argsBuilder_.clear(); + } + upsert_ = false; + bitField0_ = (bitField0_ & ~0x00000020); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Insert_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Insert getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.Insert.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Insert build() { + com.mysql.cj.x.protobuf.MysqlxCrud.Insert result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Insert buildPartial() { + com.mysql.cj.x.protobuf.MysqlxCrud.Insert result = new com.mysql.cj.x.protobuf.MysqlxCrud.Insert(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + if (collectionBuilder_ == null) { + result.collection_ = collection_; + } else { + result.collection_ = collectionBuilder_.build(); + } + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + to_bitField0_ |= 0x00000002; + } + result.dataModel_ = dataModel_; + if (projectionBuilder_ == null) { + if (((bitField0_ & 0x00000004) != 0)) { + projection_ = java.util.Collections.unmodifiableList(projection_); + bitField0_ = (bitField0_ & ~0x00000004); + } + result.projection_ = projection_; + } else { + result.projection_ = projectionBuilder_.build(); + } + if (rowBuilder_ == null) { + if (((bitField0_ & 0x00000008) != 0)) { + row_ = java.util.Collections.unmodifiableList(row_); + bitField0_ = (bitField0_ & ~0x00000008); + } + result.row_ = row_; + } else { + result.row_ = rowBuilder_.build(); + } + if (argsBuilder_ == null) { + if (((bitField0_ & 0x00000010) != 0)) { + args_ = java.util.Collections.unmodifiableList(args_); + bitField0_ = (bitField0_ & ~0x00000010); + } + result.args_ = args_; + } else { + result.args_ = argsBuilder_.build(); + } + if (((from_bitField0_ & 0x00000020) != 0)) { + result.upsert_ = upsert_; + to_bitField0_ |= 0x00000004; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxCrud.Insert) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxCrud.Insert)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxCrud.Insert other) { + if (other == com.mysql.cj.x.protobuf.MysqlxCrud.Insert.getDefaultInstance()) return this; + if (other.hasCollection()) { + mergeCollection(other.getCollection()); + } + if (other.hasDataModel()) { + setDataModel(other.getDataModel()); + } + if (projectionBuilder_ == null) { + if (!other.projection_.isEmpty()) { + if (projection_.isEmpty()) { + projection_ = other.projection_; + bitField0_ = (bitField0_ & ~0x00000004); + } else { + ensureProjectionIsMutable(); + projection_.addAll(other.projection_); + } + onChanged(); + } + } else { + if (!other.projection_.isEmpty()) { + if (projectionBuilder_.isEmpty()) { + projectionBuilder_.dispose(); + projectionBuilder_ = null; + projection_ = other.projection_; + bitField0_ = (bitField0_ & ~0x00000004); + projectionBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getProjectionFieldBuilder() : null; + } else { + projectionBuilder_.addAllMessages(other.projection_); + } + } + } + if (rowBuilder_ == null) { + if (!other.row_.isEmpty()) { + if (row_.isEmpty()) { + row_ = other.row_; + bitField0_ = (bitField0_ & ~0x00000008); + } else { + ensureRowIsMutable(); + row_.addAll(other.row_); + } + onChanged(); + } + } else { + if (!other.row_.isEmpty()) { + if (rowBuilder_.isEmpty()) { + rowBuilder_.dispose(); + rowBuilder_ = null; + row_ = other.row_; + bitField0_ = (bitField0_ & ~0x00000008); + rowBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getRowFieldBuilder() : null; + } else { + rowBuilder_.addAllMessages(other.row_); + } + } + } + if (argsBuilder_ == null) { + if (!other.args_.isEmpty()) { + if (args_.isEmpty()) { + args_ = other.args_; + bitField0_ = (bitField0_ & ~0x00000010); + } else { + ensureArgsIsMutable(); + args_.addAll(other.args_); + } + onChanged(); + } + } else { + if (!other.args_.isEmpty()) { + if (argsBuilder_.isEmpty()) { + argsBuilder_.dispose(); + argsBuilder_ = null; + args_ = other.args_; + bitField0_ = (bitField0_ & ~0x00000010); + argsBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getArgsFieldBuilder() : null; + } else { + argsBuilder_.addAllMessages(other.args_); + } + } + } + if (other.hasUpsert()) { + setUpsert(other.getUpsert()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasCollection()) { + return false; + } + if (!getCollection().isInitialized()) { + return false; + } + for (int i = 0; i < getProjectionCount(); i++) { + if (!getProjection(i).isInitialized()) { + return false; + } + } + for (int i = 0; i < getRowCount(); i++) { + if (!getRow(i).isInitialized()) { + return false; + } + } + for (int i = 0; i < getArgsCount(); i++) { + if (!getArgs(i).isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxCrud.Insert parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxCrud.Insert) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private com.mysql.cj.x.protobuf.MysqlxCrud.Collection collection_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Collection, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder> collectionBuilder_; + /** + * 
+       ** collection to insert into 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return Whether the collection field is set. + */ + public boolean hasCollection() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** collection to insert into 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return The collection. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection getCollection() { + if (collectionBuilder_ == null) { + return collection_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } else { + return collectionBuilder_.getMessage(); + } + } + /** + * 
+       ** collection to insert into 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public Builder setCollection(com.mysql.cj.x.protobuf.MysqlxCrud.Collection value) { + if (collectionBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + collection_ = value; + onChanged(); + } else { + collectionBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** collection to insert into 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public Builder setCollection( + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder builderForValue) { + if (collectionBuilder_ == null) { + collection_ = builderForValue.build(); + onChanged(); + } else { + collectionBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** collection to insert into 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public Builder mergeCollection(com.mysql.cj.x.protobuf.MysqlxCrud.Collection value) { + if (collectionBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0) && + collection_ != null && + collection_ != com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance()) { + collection_ = + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.newBuilder(collection_).mergeFrom(value).buildPartial(); + } else { + collection_ = value; + } + onChanged(); + } else { + collectionBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** collection to insert into 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public Builder clearCollection() { + if (collectionBuilder_ == null) { + collection_ = null; + onChanged(); + } else { + collectionBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + /** + * 
+       ** collection to insert into 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder getCollectionBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getCollectionFieldBuilder().getBuilder(); + } + /** + * 
+       ** collection to insert into 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder getCollectionOrBuilder() { + if (collectionBuilder_ != null) { + return collectionBuilder_.getMessageOrBuilder(); + } else { + return collection_ == null ? + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } + } + /** + * 
+       ** collection to insert into 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Collection, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder> + getCollectionFieldBuilder() { + if (collectionBuilder_ == null) { + collectionBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Collection, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder>( + getCollection(), + getParentForChildren(), + isClean()); + collection_ = null; + } + return collectionBuilder_; + } + + private int dataModel_ = 1; + /** + * 
+       ** data model that the operations refer to 
+       *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 2; + * @return Whether the dataModel field is set. + */ + public boolean hasDataModel() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** data model that the operations refer to 
+       *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 2; + * @return The dataModel. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.DataModel getDataModel() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.DataModel result = com.mysql.cj.x.protobuf.MysqlxCrud.DataModel.valueOf(dataModel_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.DataModel.DOCUMENT : result; + } + /** + * 
+       ** data model that the operations refer to 
+       *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 2; + * @param value The dataModel to set. + * @return This builder for chaining. + */ + public Builder setDataModel(com.mysql.cj.x.protobuf.MysqlxCrud.DataModel value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + dataModel_ = value.getNumber(); + onChanged(); + return this; + } + /** + * 
+       ** data model that the operations refer to 
+       *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 2; + * @return This builder for chaining. + */ + public Builder clearDataModel() { + bitField0_ = (bitField0_ & ~0x00000002); + dataModel_ = 1; + onChanged(); + return this; + } + + private java.util.List projection_ = + java.util.Collections.emptyList(); + private void ensureProjectionIsMutable() { + if (!((bitField0_ & 0x00000004) != 0)) { + projection_ = new java.util.ArrayList(projection_); + bitField0_ |= 0x00000004; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Column, com.mysql.cj.x.protobuf.MysqlxCrud.Column.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.ColumnOrBuilder> projectionBuilder_; + + /** + * 
+       ** name of the columns to insert data into
+       *(empty if data_model is DOCUMENT) 
+       *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public java.util.List getProjectionList() { + if (projectionBuilder_ == null) { + return java.util.Collections.unmodifiableList(projection_); + } else { + return projectionBuilder_.getMessageList(); + } + } + /** + * 
+       ** name of the columns to insert data into
+       *(empty if data_model is DOCUMENT) 
+       *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public int getProjectionCount() { + if (projectionBuilder_ == null) { + return projection_.size(); + } else { + return projectionBuilder_.getCount(); + } + } + /** + * 
+       ** name of the columns to insert data into
+       *(empty if data_model is DOCUMENT) 
+       *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Column getProjection(int index) { + if (projectionBuilder_ == null) { + return projection_.get(index); + } else { + return projectionBuilder_.getMessage(index); + } + } + /** + * 
+       ** name of the columns to insert data into
+       *(empty if data_model is DOCUMENT) 
+       *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public Builder setProjection( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Column value) { + if (projectionBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureProjectionIsMutable(); + projection_.set(index, value); + onChanged(); + } else { + projectionBuilder_.setMessage(index, value); + } + return this; + } + /** + * 
+       ** name of the columns to insert data into
+       *(empty if data_model is DOCUMENT) 
+       *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public Builder setProjection( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Column.Builder builderForValue) { + if (projectionBuilder_ == null) { + ensureProjectionIsMutable(); + projection_.set(index, builderForValue.build()); + onChanged(); + } else { + projectionBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** name of the columns to insert data into
+       *(empty if data_model is DOCUMENT) 
+       *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public Builder addProjection(com.mysql.cj.x.protobuf.MysqlxCrud.Column value) { + if (projectionBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureProjectionIsMutable(); + projection_.add(value); + onChanged(); + } else { + projectionBuilder_.addMessage(value); + } + return this; + } + /** + * 
+       ** name of the columns to insert data into
+       *(empty if data_model is DOCUMENT) 
+       *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public Builder addProjection( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Column value) { + if (projectionBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureProjectionIsMutable(); + projection_.add(index, value); + onChanged(); + } else { + projectionBuilder_.addMessage(index, value); + } + return this; + } + /** + * 
+       ** name of the columns to insert data into
+       *(empty if data_model is DOCUMENT) 
+       *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public Builder addProjection( + com.mysql.cj.x.protobuf.MysqlxCrud.Column.Builder builderForValue) { + if (projectionBuilder_ == null) { + ensureProjectionIsMutable(); + projection_.add(builderForValue.build()); + onChanged(); + } else { + projectionBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * 
+       ** name of the columns to insert data into
+       *(empty if data_model is DOCUMENT) 
+       *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public Builder addProjection( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Column.Builder builderForValue) { + if (projectionBuilder_ == null) { + ensureProjectionIsMutable(); + projection_.add(index, builderForValue.build()); + onChanged(); + } else { + projectionBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** name of the columns to insert data into
+       *(empty if data_model is DOCUMENT) 
+       *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public Builder addAllProjection( + java.lang.Iterable values) { + if (projectionBuilder_ == null) { + ensureProjectionIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, projection_); + onChanged(); + } else { + projectionBuilder_.addAllMessages(values); + } + return this; + } + /** + * 
+       ** name of the columns to insert data into
+       *(empty if data_model is DOCUMENT) 
+       *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public Builder clearProjection() { + if (projectionBuilder_ == null) { + projection_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + onChanged(); + } else { + projectionBuilder_.clear(); + } + return this; + } + /** + * 
+       ** name of the columns to insert data into
+       *(empty if data_model is DOCUMENT) 
+       *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public Builder removeProjection(int index) { + if (projectionBuilder_ == null) { + ensureProjectionIsMutable(); + projection_.remove(index); + onChanged(); + } else { + projectionBuilder_.remove(index); + } + return this; + } + /** + * 
+       ** name of the columns to insert data into
+       *(empty if data_model is DOCUMENT) 
+       *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Column.Builder getProjectionBuilder( + int index) { + return getProjectionFieldBuilder().getBuilder(index); + } + /** + * 
+       ** name of the columns to insert data into
+       *(empty if data_model is DOCUMENT) 
+       *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.ColumnOrBuilder getProjectionOrBuilder( + int index) { + if (projectionBuilder_ == null) { + return projection_.get(index); } else { + return projectionBuilder_.getMessageOrBuilder(index); + } + } + /** + * 
+       ** name of the columns to insert data into
+       *(empty if data_model is DOCUMENT) 
+       *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public java.util.List + getProjectionOrBuilderList() { + if (projectionBuilder_ != null) { + return projectionBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(projection_); + } + } + /** + * 
+       ** name of the columns to insert data into
+       *(empty if data_model is DOCUMENT) 
+       *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Column.Builder addProjectionBuilder() { + return getProjectionFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxCrud.Column.getDefaultInstance()); + } + /** + * 
+       ** name of the columns to insert data into
+       *(empty if data_model is DOCUMENT) 
+       *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Column.Builder addProjectionBuilder( + int index) { + return getProjectionFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxCrud.Column.getDefaultInstance()); + } + /** + * 
+       ** name of the columns to insert data into
+       *(empty if data_model is DOCUMENT) 
+       *
+ * + * repeated .Mysqlx.Crud.Column projection = 3; + */ + public java.util.List + getProjectionBuilderList() { + return getProjectionFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Column, com.mysql.cj.x.protobuf.MysqlxCrud.Column.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.ColumnOrBuilder> + getProjectionFieldBuilder() { + if (projectionBuilder_ == null) { + projectionBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Column, com.mysql.cj.x.protobuf.MysqlxCrud.Column.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.ColumnOrBuilder>( + projection_, + ((bitField0_ & 0x00000004) != 0), + getParentForChildren(), + isClean()); + projection_ = null; + } + return projectionBuilder_; + } + + private java.util.List row_ = + java.util.Collections.emptyList(); + private void ensureRowIsMutable() { + if (!((bitField0_ & 0x00000008) != 0)) { + row_ = new java.util.ArrayList(row_); + bitField0_ |= 0x00000008; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow, com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRowOrBuilder> rowBuilder_; + + /** + * 
+       ** set of rows to insert into the collection/table (a single expression
+       *with a JSON document literal or an OBJECT expression) 
+       *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public java.util.List getRowList() { + if (rowBuilder_ == null) { + return java.util.Collections.unmodifiableList(row_); + } else { + return rowBuilder_.getMessageList(); + } + } + /** + * 
+       ** set of rows to insert into the collection/table (a single expression
+       *with a JSON document literal or an OBJECT expression) 
+       *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public int getRowCount() { + if (rowBuilder_ == null) { + return row_.size(); + } else { + return rowBuilder_.getCount(); + } + } + /** + * 
+       ** set of rows to insert into the collection/table (a single expression
+       *with a JSON document literal or an OBJECT expression) 
+       *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow getRow(int index) { + if (rowBuilder_ == null) { + return row_.get(index); + } else { + return rowBuilder_.getMessage(index); + } + } + /** + * 
+       ** set of rows to insert into the collection/table (a single expression
+       *with a JSON document literal or an OBJECT expression) 
+       *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public Builder setRow( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow value) { + if (rowBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureRowIsMutable(); + row_.set(index, value); + onChanged(); + } else { + rowBuilder_.setMessage(index, value); + } + return this; + } + /** + * 
+       ** set of rows to insert into the collection/table (a single expression
+       *with a JSON document literal or an OBJECT expression) 
+       *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public Builder setRow( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow.Builder builderForValue) { + if (rowBuilder_ == null) { + ensureRowIsMutable(); + row_.set(index, builderForValue.build()); + onChanged(); + } else { + rowBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** set of rows to insert into the collection/table (a single expression
+       *with a JSON document literal or an OBJECT expression) 
+       *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public Builder addRow(com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow value) { + if (rowBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureRowIsMutable(); + row_.add(value); + onChanged(); + } else { + rowBuilder_.addMessage(value); + } + return this; + } + /** + * 
+       ** set of rows to insert into the collection/table (a single expression
+       *with a JSON document literal or an OBJECT expression) 
+       *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public Builder addRow( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow value) { + if (rowBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureRowIsMutable(); + row_.add(index, value); + onChanged(); + } else { + rowBuilder_.addMessage(index, value); + } + return this; + } + /** + * 
+       ** set of rows to insert into the collection/table (a single expression
+       *with a JSON document literal or an OBJECT expression) 
+       *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public Builder addRow( + com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow.Builder builderForValue) { + if (rowBuilder_ == null) { + ensureRowIsMutable(); + row_.add(builderForValue.build()); + onChanged(); + } else { + rowBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * 
+       ** set of rows to insert into the collection/table (a single expression
+       *with a JSON document literal or an OBJECT expression) 
+       *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public Builder addRow( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow.Builder builderForValue) { + if (rowBuilder_ == null) { + ensureRowIsMutable(); + row_.add(index, builderForValue.build()); + onChanged(); + } else { + rowBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** set of rows to insert into the collection/table (a single expression
+       *with a JSON document literal or an OBJECT expression) 
+       *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public Builder addAllRow( + java.lang.Iterable values) { + if (rowBuilder_ == null) { + ensureRowIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, row_); + onChanged(); + } else { + rowBuilder_.addAllMessages(values); + } + return this; + } + /** + * 
+       ** set of rows to insert into the collection/table (a single expression
+       *with a JSON document literal or an OBJECT expression) 
+       *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public Builder clearRow() { + if (rowBuilder_ == null) { + row_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000008); + onChanged(); + } else { + rowBuilder_.clear(); + } + return this; + } + /** + * 
+       ** set of rows to insert into the collection/table (a single expression
+       *with a JSON document literal or an OBJECT expression) 
+       *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public Builder removeRow(int index) { + if (rowBuilder_ == null) { + ensureRowIsMutable(); + row_.remove(index); + onChanged(); + } else { + rowBuilder_.remove(index); + } + return this; + } + /** + * 
+       ** set of rows to insert into the collection/table (a single expression
+       *with a JSON document literal or an OBJECT expression) 
+       *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow.Builder getRowBuilder( + int index) { + return getRowFieldBuilder().getBuilder(index); + } + /** + * 
+       ** set of rows to insert into the collection/table (a single expression
+       *with a JSON document literal or an OBJECT expression) 
+       *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRowOrBuilder getRowOrBuilder( + int index) { + if (rowBuilder_ == null) { + return row_.get(index); } else { + return rowBuilder_.getMessageOrBuilder(index); + } + } + /** + * 
+       ** set of rows to insert into the collection/table (a single expression
+       *with a JSON document literal or an OBJECT expression) 
+       *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public java.util.List + getRowOrBuilderList() { + if (rowBuilder_ != null) { + return rowBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(row_); + } + } + /** + * 
+       ** set of rows to insert into the collection/table (a single expression
+       *with a JSON document literal or an OBJECT expression) 
+       *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow.Builder addRowBuilder() { + return getRowFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow.getDefaultInstance()); + } + /** + * 
+       ** set of rows to insert into the collection/table (a single expression
+       *with a JSON document literal or an OBJECT expression) 
+       *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow.Builder addRowBuilder( + int index) { + return getRowFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow.getDefaultInstance()); + } + /** + * 
+       ** set of rows to insert into the collection/table (a single expression
+       *with a JSON document literal or an OBJECT expression) 
+       *
+ * + * repeated .Mysqlx.Crud.Insert.TypedRow row = 4; + */ + public java.util.List + getRowBuilderList() { + return getRowFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow, com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRowOrBuilder> + getRowFieldBuilder() { + if (rowBuilder_ == null) { + rowBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow, com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRow.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.Insert.TypedRowOrBuilder>( + row_, + ((bitField0_ & 0x00000008) != 0), + getParentForChildren(), + isClean()); + row_ = null; + } + return rowBuilder_; + } + + private java.util.List args_ = + java.util.Collections.emptyList(); + private void ensureArgsIsMutable() { + if (!((bitField0_ & 0x00000010) != 0)) { + args_ = new java.util.ArrayList(args_); + bitField0_ |= 0x00000010; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder> argsBuilder_; + + /** + * 
+       ** values for parameters used in row expressions 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public java.util.List getArgsList() { + if (argsBuilder_ == null) { + return java.util.Collections.unmodifiableList(args_); + } else { + return argsBuilder_.getMessageList(); + } + } + /** + * 
+       ** values for parameters used in row expressions 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public int getArgsCount() { + if (argsBuilder_ == null) { + return args_.size(); + } else { + return argsBuilder_.getCount(); + } + } + /** + * 
+       ** values for parameters used in row expressions 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getArgs(int index) { + if (argsBuilder_ == null) { + return args_.get(index); + } else { + return argsBuilder_.getMessage(index); + } + } + /** + * 
+       ** values for parameters used in row expressions 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public Builder setArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value) { + if (argsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgsIsMutable(); + args_.set(index, value); + onChanged(); + } else { + argsBuilder_.setMessage(index, value); + } + return this; + } + /** + * 
+       ** values for parameters used in row expressions 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public Builder setArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder builderForValue) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.set(index, builderForValue.build()); + onChanged(); + } else { + argsBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** values for parameters used in row expressions 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public Builder addArgs(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value) { + if (argsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgsIsMutable(); + args_.add(value); + onChanged(); + } else { + argsBuilder_.addMessage(value); + } + return this; + } + /** + * 
+       ** values for parameters used in row expressions 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public Builder addArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value) { + if (argsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgsIsMutable(); + args_.add(index, value); + onChanged(); + } else { + argsBuilder_.addMessage(index, value); + } + return this; + } + /** + * 
+       ** values for parameters used in row expressions 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public Builder addArgs( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder builderForValue) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.add(builderForValue.build()); + onChanged(); + } else { + argsBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * 
+       ** values for parameters used in row expressions 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public Builder addArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder builderForValue) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.add(index, builderForValue.build()); + onChanged(); + } else { + argsBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** values for parameters used in row expressions 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public Builder addAllArgs( + java.lang.Iterable values) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, args_); + onChanged(); + } else { + argsBuilder_.addAllMessages(values); + } + return this; + } + /** + * 
+       ** values for parameters used in row expressions 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public Builder clearArgs() { + if (argsBuilder_ == null) { + args_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000010); + onChanged(); + } else { + argsBuilder_.clear(); + } + return this; + } + /** + * 
+       ** values for parameters used in row expressions 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public Builder removeArgs(int index) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.remove(index); + onChanged(); + } else { + argsBuilder_.remove(index); + } + return this; + } + /** + * 
+       ** values for parameters used in row expressions 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder getArgsBuilder( + int index) { + return getArgsFieldBuilder().getBuilder(index); + } + /** + * 
+       ** values for parameters used in row expressions 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getArgsOrBuilder( + int index) { + if (argsBuilder_ == null) { + return args_.get(index); } else { + return argsBuilder_.getMessageOrBuilder(index); + } + } + /** + * 
+       ** values for parameters used in row expressions 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public java.util.List + getArgsOrBuilderList() { + if (argsBuilder_ != null) { + return argsBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(args_); + } + } + /** + * 
+       ** values for parameters used in row expressions 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder addArgsBuilder() { + return getArgsFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance()); + } + /** + * 
+       ** values for parameters used in row expressions 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder addArgsBuilder( + int index) { + return getArgsFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance()); + } + /** + * 
+       ** values for parameters used in row expressions 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 5; + */ + public java.util.List + getArgsBuilderList() { + return getArgsFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder> + getArgsFieldBuilder() { + if (argsBuilder_ == null) { + argsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder>( + args_, + ((bitField0_ & 0x00000010) != 0), + getParentForChildren(), + isClean()); + args_ = null; + } + return argsBuilder_; + } + + private boolean upsert_ ; + /** + * 
+       ** true if this should be treated as an Upsert
+       *(that is, update on duplicate key) 
+       *
+ * + * optional bool upsert = 6 [default = false]; + * @return Whether the upsert field is set. + */ + public boolean hasUpsert() { + return ((bitField0_ & 0x00000020) != 0); + } + /** + * 
+       ** true if this should be treated as an Upsert
+       *(that is, update on duplicate key) 
+       *
+ * + * optional bool upsert = 6 [default = false]; + * @return The upsert. + */ + public boolean getUpsert() { + return upsert_; + } + /** + * 
+       ** true if this should be treated as an Upsert
+       *(that is, update on duplicate key) 
+       *
+ * + * optional bool upsert = 6 [default = false]; + * @param value The upsert to set. + * @return This builder for chaining. + */ + public Builder setUpsert(boolean value) { + bitField0_ |= 0x00000020; + upsert_ = value; + onChanged(); + return this; + } + /** + * 
+       ** true if this should be treated as an Upsert
+       *(that is, update on duplicate key) 
+       *
+ * + * optional bool upsert = 6 [default = false]; + * @return This builder for chaining. + */ + public Builder clearUpsert() { + bitField0_ = (bitField0_ & ~0x00000020); + upsert_ = false; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Crud.Insert) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Crud.Insert) + private static final com.mysql.cj.x.protobuf.MysqlxCrud.Insert DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxCrud.Insert(); + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.Insert getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Insert parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Insert(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Insert getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface UpdateOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Crud.Update) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** collection to change 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + * @return Whether the collection field is set. + */ + boolean hasCollection(); + /** + * 
+     ** collection to change 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + * @return The collection. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Collection getCollection(); + /** + * 
+     ** collection to change 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder getCollectionOrBuilder(); + + /** + * 
+     ** datamodel that the operations refer to  
+     *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 3; + * @return Whether the dataModel field is set. + */ + boolean hasDataModel(); + /** + * 
+     ** datamodel that the operations refer to  
+     *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 3; + * @return The dataModel. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.DataModel getDataModel(); + + /** + * 
+     ** filter expression to match rows that the operations will apply on 
+     *
+ * + * optional .Mysqlx.Expr.Expr criteria = 4; + * @return Whether the criteria field is set. + */ + boolean hasCriteria(); + /** + * 
+     ** filter expression to match rows that the operations will apply on 
+     *
+ * + * optional .Mysqlx.Expr.Expr criteria = 4; + * @return The criteria. + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Expr getCriteria(); + /** + * 
+     ** filter expression to match rows that the operations will apply on 
+     *
+ * + * optional .Mysqlx.Expr.Expr criteria = 4; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getCriteriaOrBuilder(); + + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.Limit limit = 5; + * @return Whether the limit field is set. + */ + boolean hasLimit(); + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.Limit limit = 5; + * @return The limit. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Limit getLimit(); + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.Limit limit = 5; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.LimitOrBuilder getLimitOrBuilder(); + + /** + * 
+     ** specifies order of matched rows 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + java.util.List + getOrderList(); + /** + * 
+     ** specifies order of matched rows 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Order getOrder(int index); + /** + * 
+     ** specifies order of matched rows 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + int getOrderCount(); + /** + * 
+     ** specifies order of matched rows 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + java.util.List + getOrderOrBuilderList(); + /** + * 
+     ** specifies order of matched rows 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.OrderOrBuilder getOrderOrBuilder( + int index); + + /** + * 
+     ** list of operations to be applied.
+     *Valid operations will depend on the data_model 
+     *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + java.util.List + getOperationList(); + /** + * 
+     ** list of operations to be applied.
+     *Valid operations will depend on the data_model 
+     *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation getOperation(int index); + /** + * 
+     ** list of operations to be applied.
+     *Valid operations will depend on the data_model 
+     *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + int getOperationCount(); + /** + * 
+     ** list of operations to be applied.
+     *Valid operations will depend on the data_model 
+     *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + java.util.List + getOperationOrBuilderList(); + /** + * 
+     ** list of operations to be applied.
+     *Valid operations will depend on the data_model 
+     *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperationOrBuilder getOperationOrBuilder( + int index); + + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + java.util.List + getArgsList(); + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getArgs(int index); + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + int getArgsCount(); + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + java.util.List + getArgsOrBuilderList(); + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getArgsOrBuilder( + int index); + + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 9; + * @return Whether the limitExpr field is set. + */ + boolean hasLimitExpr(); + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 9; + * @return The limitExpr. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr getLimitExpr(); + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 9; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExprOrBuilder getLimitExprOrBuilder(); + } + /** + * 
+   **
+   *Update documents/rows in a collection/table
+   *@returns @ref Mysqlx::Resultset
+   *
+ * + * Protobuf type {@code Mysqlx.Crud.Update} + */ + public static final class Update extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Crud.Update) + UpdateOrBuilder { + private static final long serialVersionUID = 0L; + // Use Update.newBuilder() to construct. + private Update(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Update() { + dataModel_ = 1; + order_ = java.util.Collections.emptyList(); + operation_ = java.util.Collections.emptyList(); + args_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Update(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Update( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 18: { + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) != 0)) { + subBuilder = collection_.toBuilder(); + } + collection_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Collection.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(collection_); + collection_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 24: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.DataModel value = com.mysql.cj.x.protobuf.MysqlxCrud.DataModel.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(3, rawValue); + } else { + bitField0_ |= 0x00000002; + dataModel_ = rawValue; + } + break; + } + case 34: { + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) != 0)) { + subBuilder = criteria_.toBuilder(); + } + criteria_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.Expr.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(criteria_); + criteria_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 42: { + com.mysql.cj.x.protobuf.MysqlxCrud.Limit.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) != 0)) { + subBuilder = limit_.toBuilder(); + } + limit_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Limit.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(limit_); + limit_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + break; + } + case 50: { + if (!((mutable_bitField0_ & 0x00000010) != 0)) { + order_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000010; + } + order_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Order.PARSER, extensionRegistry)); + break; + } + case 58: { + if (!((mutable_bitField0_ & 0x00000020) != 0)) { + operation_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000020; + } + operation_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.PARSER, extensionRegistry)); + break; + } + case 66: { + if (!((mutable_bitField0_ & 0x00000040) != 0)) { + args_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000040; + } + args_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.PARSER, extensionRegistry)); + break; + } + case 74: { + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.Builder subBuilder = null; + if (((bitField0_ & 0x00000010) != 0)) { + subBuilder = limitExpr_.toBuilder(); + } + limitExpr_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(limitExpr_); + limitExpr_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000010; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000010) != 0)) { + order_ = java.util.Collections.unmodifiableList(order_); + } + if (((mutable_bitField0_ & 0x00000020) != 0)) { + operation_ = java.util.Collections.unmodifiableList(operation_); + } + if (((mutable_bitField0_ & 0x00000040) != 0)) { + args_ = java.util.Collections.unmodifiableList(args_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Update_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Update_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.Update.class, com.mysql.cj.x.protobuf.MysqlxCrud.Update.Builder.class); + } + + private int bitField0_; + public static final int COLLECTION_FIELD_NUMBER = 2; + private com.mysql.cj.x.protobuf.MysqlxCrud.Collection collection_; + /** + * 
+     ** collection to change 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + * @return Whether the collection field is set. + */ + public boolean hasCollection() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** collection to change 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + * @return The collection. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection getCollection() { + return collection_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } + /** + * 
+     ** collection to change 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder getCollectionOrBuilder() { + return collection_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } + + public static final int DATA_MODEL_FIELD_NUMBER = 3; + private int dataModel_; + /** + * 
+     ** datamodel that the operations refer to  
+     *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 3; + * @return Whether the dataModel field is set. + */ + public boolean hasDataModel() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** datamodel that the operations refer to  
+     *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 3; + * @return The dataModel. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.DataModel getDataModel() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.DataModel result = com.mysql.cj.x.protobuf.MysqlxCrud.DataModel.valueOf(dataModel_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.DataModel.DOCUMENT : result; + } + + public static final int CRITERIA_FIELD_NUMBER = 4; + private com.mysql.cj.x.protobuf.MysqlxExpr.Expr criteria_; + /** + * 
+     ** filter expression to match rows that the operations will apply on 
+     *
+ * + * optional .Mysqlx.Expr.Expr criteria = 4; + * @return Whether the criteria field is set. + */ + public boolean hasCriteria() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+     ** filter expression to match rows that the operations will apply on 
+     *
+ * + * optional .Mysqlx.Expr.Expr criteria = 4; + * @return The criteria. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getCriteria() { + return criteria_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : criteria_; + } + /** + * 
+     ** filter expression to match rows that the operations will apply on 
+     *
+ * + * optional .Mysqlx.Expr.Expr criteria = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getCriteriaOrBuilder() { + return criteria_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : criteria_; + } + + public static final int LIMIT_FIELD_NUMBER = 5; + private com.mysql.cj.x.protobuf.MysqlxCrud.Limit limit_; + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.Limit limit = 5; + * @return Whether the limit field is set. + */ + public boolean hasLimit() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.Limit limit = 5; + * @return The limit. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Limit getLimit() { + return limit_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Limit.getDefaultInstance() : limit_; + } + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.Limit limit = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitOrBuilder getLimitOrBuilder() { + return limit_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Limit.getDefaultInstance() : limit_; + } + + public static final int ORDER_FIELD_NUMBER = 6; + private java.util.List order_; + /** + * 
+     ** specifies order of matched rows 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public java.util.List getOrderList() { + return order_; + } + /** + * 
+     ** specifies order of matched rows 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public java.util.List + getOrderOrBuilderList() { + return order_; + } + /** + * 
+     ** specifies order of matched rows 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public int getOrderCount() { + return order_.size(); + } + /** + * 
+     ** specifies order of matched rows 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Order getOrder(int index) { + return order_.get(index); + } + /** + * 
+     ** specifies order of matched rows 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.OrderOrBuilder getOrderOrBuilder( + int index) { + return order_.get(index); + } + + public static final int OPERATION_FIELD_NUMBER = 7; + private java.util.List operation_; + /** + * 
+     ** list of operations to be applied.
+     *Valid operations will depend on the data_model 
+     *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public java.util.List getOperationList() { + return operation_; + } + /** + * 
+     ** list of operations to be applied.
+     *Valid operations will depend on the data_model 
+     *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public java.util.List + getOperationOrBuilderList() { + return operation_; + } + /** + * 
+     ** list of operations to be applied.
+     *Valid operations will depend on the data_model 
+     *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public int getOperationCount() { + return operation_.size(); + } + /** + * 
+     ** list of operations to be applied.
+     *Valid operations will depend on the data_model 
+     *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation getOperation(int index) { + return operation_.get(index); + } + /** + * 
+     ** list of operations to be applied.
+     *Valid operations will depend on the data_model 
+     *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperationOrBuilder getOperationOrBuilder( + int index) { + return operation_.get(index); + } + + public static final int ARGS_FIELD_NUMBER = 8; + private java.util.List args_; + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public java.util.List getArgsList() { + return args_; + } + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public java.util.List + getArgsOrBuilderList() { + return args_; + } + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public int getArgsCount() { + return args_.size(); + } + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getArgs(int index) { + return args_.get(index); + } + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getArgsOrBuilder( + int index) { + return args_.get(index); + } + + public static final int LIMIT_EXPR_FIELD_NUMBER = 9; + private com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr limitExpr_; + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 9; + * @return Whether the limitExpr field is set. + */ + public boolean hasLimitExpr() { + return ((bitField0_ & 0x00000010) != 0); + } + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 9; + * @return The limitExpr. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr getLimitExpr() { + return limitExpr_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.getDefaultInstance() : limitExpr_; + } + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 9; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitExprOrBuilder getLimitExprOrBuilder() { + return limitExpr_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.getDefaultInstance() : limitExpr_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasCollection()) { + memoizedIsInitialized = 0; + return false; + } + if (!getCollection().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (hasCriteria()) { + if (!getCriteria().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasLimit()) { + if (!getLimit().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + for (int i = 0; i < getOrderCount(); i++) { + if (!getOrder(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + for (int i = 0; i < getOperationCount(); i++) { + if (!getOperation(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + for (int i = 0; i < getArgsCount(); i++) { + if (!getArgs(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasLimitExpr()) { + if (!getLimitExpr().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeMessage(2, getCollection()); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeEnum(3, dataModel_); + } + if (((bitField0_ & 0x00000004) != 0)) { + output.writeMessage(4, getCriteria()); + } + if (((bitField0_ & 0x00000008) != 0)) { + output.writeMessage(5, getLimit()); + } + for (int i = 0; i < order_.size(); i++) { + output.writeMessage(6, order_.get(i)); + } + for (int i = 0; i < operation_.size(); i++) { + output.writeMessage(7, operation_.get(i)); + } + for (int i = 0; i < args_.size(); i++) { + output.writeMessage(8, args_.get(i)); + } + if (((bitField0_ & 0x00000010) != 0)) { + output.writeMessage(9, getLimitExpr()); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, getCollection()); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(3, dataModel_); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, getCriteria()); + } + if (((bitField0_ & 0x00000008) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(5, getLimit()); + } + for (int i = 0; i < order_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(6, order_.get(i)); + } + for (int i = 0; i < operation_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(7, operation_.get(i)); + } + for (int i = 0; i < args_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(8, args_.get(i)); + } + if (((bitField0_ & 0x00000010) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(9, getLimitExpr()); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxCrud.Update)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxCrud.Update other = (com.mysql.cj.x.protobuf.MysqlxCrud.Update) obj; + + if (hasCollection() != other.hasCollection()) return false; + if (hasCollection()) { + if (!getCollection() + .equals(other.getCollection())) return false; + } + if (hasDataModel() != other.hasDataModel()) return false; + if (hasDataModel()) { + if (dataModel_ != other.dataModel_) return false; + } + if (hasCriteria() != other.hasCriteria()) return false; + if (hasCriteria()) { + if (!getCriteria() + .equals(other.getCriteria())) return false; + } + if (hasLimit() != other.hasLimit()) return false; + if (hasLimit()) { + if (!getLimit() + .equals(other.getLimit())) return false; + } + if (!getOrderList() + .equals(other.getOrderList())) return false; + if (!getOperationList() + .equals(other.getOperationList())) return false; + if (!getArgsList() + .equals(other.getArgsList())) return false; + if (hasLimitExpr() != other.hasLimitExpr()) return false; + if (hasLimitExpr()) { + if (!getLimitExpr() + .equals(other.getLimitExpr())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasCollection()) { + hash = (37 * hash) + COLLECTION_FIELD_NUMBER; + hash = (53 * hash) + getCollection().hashCode(); + } + if (hasDataModel()) { + hash = (37 * hash) + DATA_MODEL_FIELD_NUMBER; + hash = (53 * hash) + dataModel_; + } + if (hasCriteria()) { + hash = (37 * hash) + CRITERIA_FIELD_NUMBER; + hash = (53 * hash) + getCriteria().hashCode(); + } + if (hasLimit()) { + hash = (37 * hash) + LIMIT_FIELD_NUMBER; + hash = (53 * hash) + getLimit().hashCode(); + } + if (getOrderCount() > 0) { + hash = (37 * hash) + ORDER_FIELD_NUMBER; + hash = (53 * hash) + getOrderList().hashCode(); + } + if (getOperationCount() > 0) { + hash = (37 * hash) + OPERATION_FIELD_NUMBER; + hash = (53 * hash) + getOperationList().hashCode(); + } + if (getArgsCount() > 0) { + hash = (37 * hash) + ARGS_FIELD_NUMBER; + hash = (53 * hash) + getArgsList().hashCode(); + } + if (hasLimitExpr()) { + hash = (37 * hash) + LIMIT_EXPR_FIELD_NUMBER; + hash = (53 * hash) + getLimitExpr().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.Update parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Update parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Update parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Update parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Update parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Update parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Update parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Update parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Update parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Update parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Update parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Update parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxCrud.Update prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Update documents/rows in a collection/table
+     *@returns @ref Mysqlx::Resultset
+     *
+ * + * Protobuf type {@code Mysqlx.Crud.Update} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Crud.Update) + com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Update_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Update_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.Update.class, com.mysql.cj.x.protobuf.MysqlxCrud.Update.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxCrud.Update.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getCollectionFieldBuilder(); + getCriteriaFieldBuilder(); + getLimitFieldBuilder(); + getOrderFieldBuilder(); + getOperationFieldBuilder(); + getArgsFieldBuilder(); + getLimitExprFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + if (collectionBuilder_ == null) { + collection_ = null; + } else { + collectionBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + dataModel_ = 1; + bitField0_ = (bitField0_ & ~0x00000002); + if (criteriaBuilder_ == null) { + criteria_ = null; + } else { + criteriaBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + if (limitBuilder_ == null) { + limit_ = null; + } else { + limitBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + if (orderBuilder_ == null) { + order_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000010); + } else { + orderBuilder_.clear(); + } + if (operationBuilder_ == null) { + operation_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000020); + } else { + operationBuilder_.clear(); + } + if (argsBuilder_ == null) { + args_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000040); + } else { + argsBuilder_.clear(); + } + if (limitExprBuilder_ == null) { + limitExpr_ = null; + } else { + limitExprBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000080); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Update_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Update getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.Update.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Update build() { + com.mysql.cj.x.protobuf.MysqlxCrud.Update result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Update buildPartial() { + com.mysql.cj.x.protobuf.MysqlxCrud.Update result = new com.mysql.cj.x.protobuf.MysqlxCrud.Update(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + if (collectionBuilder_ == null) { + result.collection_ = collection_; + } else { + result.collection_ = collectionBuilder_.build(); + } + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + to_bitField0_ |= 0x00000002; + } + result.dataModel_ = dataModel_; + if (((from_bitField0_ & 0x00000004) != 0)) { + if (criteriaBuilder_ == null) { + result.criteria_ = criteria_; + } else { + result.criteria_ = criteriaBuilder_.build(); + } + to_bitField0_ |= 0x00000004; + } + if (((from_bitField0_ & 0x00000008) != 0)) { + if (limitBuilder_ == null) { + result.limit_ = limit_; + } else { + result.limit_ = limitBuilder_.build(); + } + to_bitField0_ |= 0x00000008; + } + if (orderBuilder_ == null) { + if (((bitField0_ & 0x00000010) != 0)) { + order_ = java.util.Collections.unmodifiableList(order_); + bitField0_ = (bitField0_ & ~0x00000010); + } + result.order_ = order_; + } else { + result.order_ = orderBuilder_.build(); + } + if (operationBuilder_ == null) { + if (((bitField0_ & 0x00000020) != 0)) { + operation_ = java.util.Collections.unmodifiableList(operation_); + bitField0_ = (bitField0_ & ~0x00000020); + } + result.operation_ = operation_; + } else { + result.operation_ = operationBuilder_.build(); + } + if (argsBuilder_ == null) { + if (((bitField0_ & 0x00000040) != 0)) { + args_ = java.util.Collections.unmodifiableList(args_); + bitField0_ = (bitField0_ & ~0x00000040); + } + result.args_ = args_; + } else { + result.args_ = argsBuilder_.build(); + } + if (((from_bitField0_ & 0x00000080) != 0)) { + if (limitExprBuilder_ == null) { + result.limitExpr_ = limitExpr_; + } else { + result.limitExpr_ = limitExprBuilder_.build(); + } + to_bitField0_ |= 0x00000010; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxCrud.Update) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxCrud.Update)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxCrud.Update other) { + if (other == com.mysql.cj.x.protobuf.MysqlxCrud.Update.getDefaultInstance()) return this; + if (other.hasCollection()) { + mergeCollection(other.getCollection()); + } + if (other.hasDataModel()) { + setDataModel(other.getDataModel()); + } + if (other.hasCriteria()) { + mergeCriteria(other.getCriteria()); + } + if (other.hasLimit()) { + mergeLimit(other.getLimit()); + } + if (orderBuilder_ == null) { + if (!other.order_.isEmpty()) { + if (order_.isEmpty()) { + order_ = other.order_; + bitField0_ = (bitField0_ & ~0x00000010); + } else { + ensureOrderIsMutable(); + order_.addAll(other.order_); + } + onChanged(); + } + } else { + if (!other.order_.isEmpty()) { + if (orderBuilder_.isEmpty()) { + orderBuilder_.dispose(); + orderBuilder_ = null; + order_ = other.order_; + bitField0_ = (bitField0_ & ~0x00000010); + orderBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getOrderFieldBuilder() : null; + } else { + orderBuilder_.addAllMessages(other.order_); + } + } + } + if (operationBuilder_ == null) { + if (!other.operation_.isEmpty()) { + if (operation_.isEmpty()) { + operation_ = other.operation_; + bitField0_ = (bitField0_ & ~0x00000020); + } else { + ensureOperationIsMutable(); + operation_.addAll(other.operation_); + } + onChanged(); + } + } else { + if (!other.operation_.isEmpty()) { + if (operationBuilder_.isEmpty()) { + operationBuilder_.dispose(); + operationBuilder_ = null; + operation_ = other.operation_; + bitField0_ = (bitField0_ & ~0x00000020); + operationBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getOperationFieldBuilder() : null; + } else { + operationBuilder_.addAllMessages(other.operation_); + } + } + } + if (argsBuilder_ == null) { + if (!other.args_.isEmpty()) { + if (args_.isEmpty()) { + args_ = other.args_; + bitField0_ = (bitField0_ & ~0x00000040); + } else { + ensureArgsIsMutable(); + args_.addAll(other.args_); + } + onChanged(); + } + } else { + if (!other.args_.isEmpty()) { + if (argsBuilder_.isEmpty()) { + argsBuilder_.dispose(); + argsBuilder_ = null; + args_ = other.args_; + bitField0_ = (bitField0_ & ~0x00000040); + argsBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getArgsFieldBuilder() : null; + } else { + argsBuilder_.addAllMessages(other.args_); + } + } + } + if (other.hasLimitExpr()) { + mergeLimitExpr(other.getLimitExpr()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasCollection()) { + return false; + } + if (!getCollection().isInitialized()) { + return false; + } + if (hasCriteria()) { + if (!getCriteria().isInitialized()) { + return false; + } + } + if (hasLimit()) { + if (!getLimit().isInitialized()) { + return false; + } + } + for (int i = 0; i < getOrderCount(); i++) { + if (!getOrder(i).isInitialized()) { + return false; + } + } + for (int i = 0; i < getOperationCount(); i++) { + if (!getOperation(i).isInitialized()) { + return false; + } + } + for (int i = 0; i < getArgsCount(); i++) { + if (!getArgs(i).isInitialized()) { + return false; + } + } + if (hasLimitExpr()) { + if (!getLimitExpr().isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxCrud.Update parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxCrud.Update) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private com.mysql.cj.x.protobuf.MysqlxCrud.Collection collection_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Collection, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder> collectionBuilder_; + /** + * 
+       ** collection to change 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + * @return Whether the collection field is set. + */ + public boolean hasCollection() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** collection to change 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + * @return The collection. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection getCollection() { + if (collectionBuilder_ == null) { + return collection_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } else { + return collectionBuilder_.getMessage(); + } + } + /** + * 
+       ** collection to change 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + */ + public Builder setCollection(com.mysql.cj.x.protobuf.MysqlxCrud.Collection value) { + if (collectionBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + collection_ = value; + onChanged(); + } else { + collectionBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** collection to change 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + */ + public Builder setCollection( + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder builderForValue) { + if (collectionBuilder_ == null) { + collection_ = builderForValue.build(); + onChanged(); + } else { + collectionBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** collection to change 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + */ + public Builder mergeCollection(com.mysql.cj.x.protobuf.MysqlxCrud.Collection value) { + if (collectionBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0) && + collection_ != null && + collection_ != com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance()) { + collection_ = + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.newBuilder(collection_).mergeFrom(value).buildPartial(); + } else { + collection_ = value; + } + onChanged(); + } else { + collectionBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** collection to change 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + */ + public Builder clearCollection() { + if (collectionBuilder_ == null) { + collection_ = null; + onChanged(); + } else { + collectionBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + /** + * 
+       ** collection to change 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder getCollectionBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getCollectionFieldBuilder().getBuilder(); + } + /** + * 
+       ** collection to change 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder getCollectionOrBuilder() { + if (collectionBuilder_ != null) { + return collectionBuilder_.getMessageOrBuilder(); + } else { + return collection_ == null ? + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } + } + /** + * 
+       ** collection to change 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 2; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Collection, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder> + getCollectionFieldBuilder() { + if (collectionBuilder_ == null) { + collectionBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Collection, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder>( + getCollection(), + getParentForChildren(), + isClean()); + collection_ = null; + } + return collectionBuilder_; + } + + private int dataModel_ = 1; + /** + * 
+       ** datamodel that the operations refer to  
+       *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 3; + * @return Whether the dataModel field is set. + */ + public boolean hasDataModel() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** datamodel that the operations refer to  
+       *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 3; + * @return The dataModel. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.DataModel getDataModel() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.DataModel result = com.mysql.cj.x.protobuf.MysqlxCrud.DataModel.valueOf(dataModel_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.DataModel.DOCUMENT : result; + } + /** + * 
+       ** datamodel that the operations refer to  
+       *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 3; + * @param value The dataModel to set. + * @return This builder for chaining. + */ + public Builder setDataModel(com.mysql.cj.x.protobuf.MysqlxCrud.DataModel value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + dataModel_ = value.getNumber(); + onChanged(); + return this; + } + /** + * 
+       ** datamodel that the operations refer to  
+       *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 3; + * @return This builder for chaining. + */ + public Builder clearDataModel() { + bitField0_ = (bitField0_ & ~0x00000002); + dataModel_ = 1; + onChanged(); + return this; + } + + private com.mysql.cj.x.protobuf.MysqlxExpr.Expr criteria_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> criteriaBuilder_; + /** + * 
+       ** filter expression to match rows that the operations will apply on 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 4; + * @return Whether the criteria field is set. + */ + public boolean hasCriteria() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+       ** filter expression to match rows that the operations will apply on 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 4; + * @return The criteria. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getCriteria() { + if (criteriaBuilder_ == null) { + return criteria_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : criteria_; + } else { + return criteriaBuilder_.getMessage(); + } + } + /** + * 
+       ** filter expression to match rows that the operations will apply on 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 4; + */ + public Builder setCriteria(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (criteriaBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + criteria_ = value; + onChanged(); + } else { + criteriaBuilder_.setMessage(value); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * 
+       ** filter expression to match rows that the operations will apply on 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 4; + */ + public Builder setCriteria( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (criteriaBuilder_ == null) { + criteria_ = builderForValue.build(); + onChanged(); + } else { + criteriaBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * 
+       ** filter expression to match rows that the operations will apply on 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 4; + */ + public Builder mergeCriteria(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (criteriaBuilder_ == null) { + if (((bitField0_ & 0x00000004) != 0) && + criteria_ != null && + criteria_ != com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance()) { + criteria_ = + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.newBuilder(criteria_).mergeFrom(value).buildPartial(); + } else { + criteria_ = value; + } + onChanged(); + } else { + criteriaBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * 
+       ** filter expression to match rows that the operations will apply on 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 4; + */ + public Builder clearCriteria() { + if (criteriaBuilder_ == null) { + criteria_ = null; + onChanged(); + } else { + criteriaBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + /** + * 
+       ** filter expression to match rows that the operations will apply on 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder getCriteriaBuilder() { + bitField0_ |= 0x00000004; + onChanged(); + return getCriteriaFieldBuilder().getBuilder(); + } + /** + * 
+       ** filter expression to match rows that the operations will apply on 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getCriteriaOrBuilder() { + if (criteriaBuilder_ != null) { + return criteriaBuilder_.getMessageOrBuilder(); + } else { + return criteria_ == null ? + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : criteria_; + } + } + /** + * 
+       ** filter expression to match rows that the operations will apply on 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 4; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> + getCriteriaFieldBuilder() { + if (criteriaBuilder_ == null) { + criteriaBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder>( + getCriteria(), + getParentForChildren(), + isClean()); + criteria_ = null; + } + return criteriaBuilder_; + } + + private com.mysql.cj.x.protobuf.MysqlxCrud.Limit limit_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Limit, com.mysql.cj.x.protobuf.MysqlxCrud.Limit.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.LimitOrBuilder> limitBuilder_; + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 5; + * @return Whether the limit field is set. + */ + public boolean hasLimit() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 5; + * @return The limit. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Limit getLimit() { + if (limitBuilder_ == null) { + return limit_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Limit.getDefaultInstance() : limit_; + } else { + return limitBuilder_.getMessage(); + } + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 5; + */ + public Builder setLimit(com.mysql.cj.x.protobuf.MysqlxCrud.Limit value) { + if (limitBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + limit_ = value; + onChanged(); + } else { + limitBuilder_.setMessage(value); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 5; + */ + public Builder setLimit( + com.mysql.cj.x.protobuf.MysqlxCrud.Limit.Builder builderForValue) { + if (limitBuilder_ == null) { + limit_ = builderForValue.build(); + onChanged(); + } else { + limitBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 5; + */ + public Builder mergeLimit(com.mysql.cj.x.protobuf.MysqlxCrud.Limit value) { + if (limitBuilder_ == null) { + if (((bitField0_ & 0x00000008) != 0) && + limit_ != null && + limit_ != com.mysql.cj.x.protobuf.MysqlxCrud.Limit.getDefaultInstance()) { + limit_ = + com.mysql.cj.x.protobuf.MysqlxCrud.Limit.newBuilder(limit_).mergeFrom(value).buildPartial(); + } else { + limit_ = value; + } + onChanged(); + } else { + limitBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 5; + */ + public Builder clearLimit() { + if (limitBuilder_ == null) { + limit_ = null; + onChanged(); + } else { + limitBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Limit.Builder getLimitBuilder() { + bitField0_ |= 0x00000008; + onChanged(); + return getLimitFieldBuilder().getBuilder(); + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitOrBuilder getLimitOrBuilder() { + if (limitBuilder_ != null) { + return limitBuilder_.getMessageOrBuilder(); + } else { + return limit_ == null ? + com.mysql.cj.x.protobuf.MysqlxCrud.Limit.getDefaultInstance() : limit_; + } + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 5; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Limit, com.mysql.cj.x.protobuf.MysqlxCrud.Limit.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.LimitOrBuilder> + getLimitFieldBuilder() { + if (limitBuilder_ == null) { + limitBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Limit, com.mysql.cj.x.protobuf.MysqlxCrud.Limit.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.LimitOrBuilder>( + getLimit(), + getParentForChildren(), + isClean()); + limit_ = null; + } + return limitBuilder_; + } + + private java.util.List order_ = + java.util.Collections.emptyList(); + private void ensureOrderIsMutable() { + if (!((bitField0_ & 0x00000010) != 0)) { + order_ = new java.util.ArrayList(order_); + bitField0_ |= 0x00000010; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Order, com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.OrderOrBuilder> orderBuilder_; + + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public java.util.List getOrderList() { + if (orderBuilder_ == null) { + return java.util.Collections.unmodifiableList(order_); + } else { + return orderBuilder_.getMessageList(); + } + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public int getOrderCount() { + if (orderBuilder_ == null) { + return order_.size(); + } else { + return orderBuilder_.getCount(); + } + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Order getOrder(int index) { + if (orderBuilder_ == null) { + return order_.get(index); + } else { + return orderBuilder_.getMessage(index); + } + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public Builder setOrder( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Order value) { + if (orderBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureOrderIsMutable(); + order_.set(index, value); + onChanged(); + } else { + orderBuilder_.setMessage(index, value); + } + return this; + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public Builder setOrder( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder builderForValue) { + if (orderBuilder_ == null) { + ensureOrderIsMutable(); + order_.set(index, builderForValue.build()); + onChanged(); + } else { + orderBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public Builder addOrder(com.mysql.cj.x.protobuf.MysqlxCrud.Order value) { + if (orderBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureOrderIsMutable(); + order_.add(value); + onChanged(); + } else { + orderBuilder_.addMessage(value); + } + return this; + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public Builder addOrder( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Order value) { + if (orderBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureOrderIsMutable(); + order_.add(index, value); + onChanged(); + } else { + orderBuilder_.addMessage(index, value); + } + return this; + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public Builder addOrder( + com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder builderForValue) { + if (orderBuilder_ == null) { + ensureOrderIsMutable(); + order_.add(builderForValue.build()); + onChanged(); + } else { + orderBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public Builder addOrder( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder builderForValue) { + if (orderBuilder_ == null) { + ensureOrderIsMutable(); + order_.add(index, builderForValue.build()); + onChanged(); + } else { + orderBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public Builder addAllOrder( + java.lang.Iterable values) { + if (orderBuilder_ == null) { + ensureOrderIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, order_); + onChanged(); + } else { + orderBuilder_.addAllMessages(values); + } + return this; + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public Builder clearOrder() { + if (orderBuilder_ == null) { + order_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000010); + onChanged(); + } else { + orderBuilder_.clear(); + } + return this; + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public Builder removeOrder(int index) { + if (orderBuilder_ == null) { + ensureOrderIsMutable(); + order_.remove(index); + onChanged(); + } else { + orderBuilder_.remove(index); + } + return this; + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder getOrderBuilder( + int index) { + return getOrderFieldBuilder().getBuilder(index); + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.OrderOrBuilder getOrderOrBuilder( + int index) { + if (orderBuilder_ == null) { + return order_.get(index); } else { + return orderBuilder_.getMessageOrBuilder(index); + } + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public java.util.List + getOrderOrBuilderList() { + if (orderBuilder_ != null) { + return orderBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(order_); + } + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder addOrderBuilder() { + return getOrderFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxCrud.Order.getDefaultInstance()); + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder addOrderBuilder( + int index) { + return getOrderFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxCrud.Order.getDefaultInstance()); + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 6; + */ + public java.util.List + getOrderBuilderList() { + return getOrderFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Order, com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.OrderOrBuilder> + getOrderFieldBuilder() { + if (orderBuilder_ == null) { + orderBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Order, com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.OrderOrBuilder>( + order_, + ((bitField0_ & 0x00000010) != 0), + getParentForChildren(), + isClean()); + order_ = null; + } + return orderBuilder_; + } + + private java.util.List operation_ = + java.util.Collections.emptyList(); + private void ensureOperationIsMutable() { + if (!((bitField0_ & 0x00000020) != 0)) { + operation_ = new java.util.ArrayList(operation_); + bitField0_ |= 0x00000020; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation, com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperationOrBuilder> operationBuilder_; + + /** + * 
+       ** list of operations to be applied.
+       *Valid operations will depend on the data_model 
+       *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public java.util.List getOperationList() { + if (operationBuilder_ == null) { + return java.util.Collections.unmodifiableList(operation_); + } else { + return operationBuilder_.getMessageList(); + } + } + /** + * 
+       ** list of operations to be applied.
+       *Valid operations will depend on the data_model 
+       *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public int getOperationCount() { + if (operationBuilder_ == null) { + return operation_.size(); + } else { + return operationBuilder_.getCount(); + } + } + /** + * 
+       ** list of operations to be applied.
+       *Valid operations will depend on the data_model 
+       *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation getOperation(int index) { + if (operationBuilder_ == null) { + return operation_.get(index); + } else { + return operationBuilder_.getMessage(index); + } + } + /** + * 
+       ** list of operations to be applied.
+       *Valid operations will depend on the data_model 
+       *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public Builder setOperation( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation value) { + if (operationBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureOperationIsMutable(); + operation_.set(index, value); + onChanged(); + } else { + operationBuilder_.setMessage(index, value); + } + return this; + } + /** + * 
+       ** list of operations to be applied.
+       *Valid operations will depend on the data_model 
+       *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public Builder setOperation( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.Builder builderForValue) { + if (operationBuilder_ == null) { + ensureOperationIsMutable(); + operation_.set(index, builderForValue.build()); + onChanged(); + } else { + operationBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** list of operations to be applied.
+       *Valid operations will depend on the data_model 
+       *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public Builder addOperation(com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation value) { + if (operationBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureOperationIsMutable(); + operation_.add(value); + onChanged(); + } else { + operationBuilder_.addMessage(value); + } + return this; + } + /** + * 
+       ** list of operations to be applied.
+       *Valid operations will depend on the data_model 
+       *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public Builder addOperation( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation value) { + if (operationBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureOperationIsMutable(); + operation_.add(index, value); + onChanged(); + } else { + operationBuilder_.addMessage(index, value); + } + return this; + } + /** + * 
+       ** list of operations to be applied.
+       *Valid operations will depend on the data_model 
+       *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public Builder addOperation( + com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.Builder builderForValue) { + if (operationBuilder_ == null) { + ensureOperationIsMutable(); + operation_.add(builderForValue.build()); + onChanged(); + } else { + operationBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * 
+       ** list of operations to be applied.
+       *Valid operations will depend on the data_model 
+       *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public Builder addOperation( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.Builder builderForValue) { + if (operationBuilder_ == null) { + ensureOperationIsMutable(); + operation_.add(index, builderForValue.build()); + onChanged(); + } else { + operationBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** list of operations to be applied.
+       *Valid operations will depend on the data_model 
+       *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public Builder addAllOperation( + java.lang.Iterable values) { + if (operationBuilder_ == null) { + ensureOperationIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, operation_); + onChanged(); + } else { + operationBuilder_.addAllMessages(values); + } + return this; + } + /** + * 
+       ** list of operations to be applied.
+       *Valid operations will depend on the data_model 
+       *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public Builder clearOperation() { + if (operationBuilder_ == null) { + operation_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000020); + onChanged(); + } else { + operationBuilder_.clear(); + } + return this; + } + /** + * 
+       ** list of operations to be applied.
+       *Valid operations will depend on the data_model 
+       *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public Builder removeOperation(int index) { + if (operationBuilder_ == null) { + ensureOperationIsMutable(); + operation_.remove(index); + onChanged(); + } else { + operationBuilder_.remove(index); + } + return this; + } + /** + * 
+       ** list of operations to be applied.
+       *Valid operations will depend on the data_model 
+       *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.Builder getOperationBuilder( + int index) { + return getOperationFieldBuilder().getBuilder(index); + } + /** + * 
+       ** list of operations to be applied.
+       *Valid operations will depend on the data_model 
+       *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperationOrBuilder getOperationOrBuilder( + int index) { + if (operationBuilder_ == null) { + return operation_.get(index); } else { + return operationBuilder_.getMessageOrBuilder(index); + } + } + /** + * 
+       ** list of operations to be applied.
+       *Valid operations will depend on the data_model 
+       *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public java.util.List + getOperationOrBuilderList() { + if (operationBuilder_ != null) { + return operationBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(operation_); + } + } + /** + * 
+       ** list of operations to be applied.
+       *Valid operations will depend on the data_model 
+       *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.Builder addOperationBuilder() { + return getOperationFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.getDefaultInstance()); + } + /** + * 
+       ** list of operations to be applied.
+       *Valid operations will depend on the data_model 
+       *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.Builder addOperationBuilder( + int index) { + return getOperationFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.getDefaultInstance()); + } + /** + * 
+       ** list of operations to be applied.
+       *Valid operations will depend on the data_model 
+       *
+ * + * repeated .Mysqlx.Crud.UpdateOperation operation = 7; + */ + public java.util.List + getOperationBuilderList() { + return getOperationFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation, com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperationOrBuilder> + getOperationFieldBuilder() { + if (operationBuilder_ == null) { + operationBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation, com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperation.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOperationOrBuilder>( + operation_, + ((bitField0_ & 0x00000020) != 0), + getParentForChildren(), + isClean()); + operation_ = null; + } + return operationBuilder_; + } + + private java.util.List args_ = + java.util.Collections.emptyList(); + private void ensureArgsIsMutable() { + if (!((bitField0_ & 0x00000040) != 0)) { + args_ = new java.util.ArrayList(args_); + bitField0_ |= 0x00000040; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder> argsBuilder_; + + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public java.util.List getArgsList() { + if (argsBuilder_ == null) { + return java.util.Collections.unmodifiableList(args_); + } else { + return argsBuilder_.getMessageList(); + } + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public int getArgsCount() { + if (argsBuilder_ == null) { + return args_.size(); + } else { + return argsBuilder_.getCount(); + } + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getArgs(int index) { + if (argsBuilder_ == null) { + return args_.get(index); + } else { + return argsBuilder_.getMessage(index); + } + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public Builder setArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value) { + if (argsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgsIsMutable(); + args_.set(index, value); + onChanged(); + } else { + argsBuilder_.setMessage(index, value); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public Builder setArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder builderForValue) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.set(index, builderForValue.build()); + onChanged(); + } else { + argsBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public Builder addArgs(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value) { + if (argsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgsIsMutable(); + args_.add(value); + onChanged(); + } else { + argsBuilder_.addMessage(value); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public Builder addArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value) { + if (argsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgsIsMutable(); + args_.add(index, value); + onChanged(); + } else { + argsBuilder_.addMessage(index, value); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public Builder addArgs( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder builderForValue) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.add(builderForValue.build()); + onChanged(); + } else { + argsBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public Builder addArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder builderForValue) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.add(index, builderForValue.build()); + onChanged(); + } else { + argsBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public Builder addAllArgs( + java.lang.Iterable values) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, args_); + onChanged(); + } else { + argsBuilder_.addAllMessages(values); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public Builder clearArgs() { + if (argsBuilder_ == null) { + args_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000040); + onChanged(); + } else { + argsBuilder_.clear(); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public Builder removeArgs(int index) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.remove(index); + onChanged(); + } else { + argsBuilder_.remove(index); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder getArgsBuilder( + int index) { + return getArgsFieldBuilder().getBuilder(index); + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getArgsOrBuilder( + int index) { + if (argsBuilder_ == null) { + return args_.get(index); } else { + return argsBuilder_.getMessageOrBuilder(index); + } + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public java.util.List + getArgsOrBuilderList() { + if (argsBuilder_ != null) { + return argsBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(args_); + } + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder addArgsBuilder() { + return getArgsFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance()); + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder addArgsBuilder( + int index) { + return getArgsFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance()); + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 8; + */ + public java.util.List + getArgsBuilderList() { + return getArgsFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder> + getArgsFieldBuilder() { + if (argsBuilder_ == null) { + argsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder>( + args_, + ((bitField0_ & 0x00000040) != 0), + getParentForChildren(), + isClean()); + args_ = null; + } + return argsBuilder_; + } + + private com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr limitExpr_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr, com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.LimitExprOrBuilder> limitExprBuilder_; + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 9; + * @return Whether the limitExpr field is set. + */ + public boolean hasLimitExpr() { + return ((bitField0_ & 0x00000080) != 0); + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 9; + * @return The limitExpr. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr getLimitExpr() { + if (limitExprBuilder_ == null) { + return limitExpr_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.getDefaultInstance() : limitExpr_; + } else { + return limitExprBuilder_.getMessage(); + } + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 9; + */ + public Builder setLimitExpr(com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr value) { + if (limitExprBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + limitExpr_ = value; + onChanged(); + } else { + limitExprBuilder_.setMessage(value); + } + bitField0_ |= 0x00000080; + return this; + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 9; + */ + public Builder setLimitExpr( + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.Builder builderForValue) { + if (limitExprBuilder_ == null) { + limitExpr_ = builderForValue.build(); + onChanged(); + } else { + limitExprBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000080; + return this; + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 9; + */ + public Builder mergeLimitExpr(com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr value) { + if (limitExprBuilder_ == null) { + if (((bitField0_ & 0x00000080) != 0) && + limitExpr_ != null && + limitExpr_ != com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.getDefaultInstance()) { + limitExpr_ = + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.newBuilder(limitExpr_).mergeFrom(value).buildPartial(); + } else { + limitExpr_ = value; + } + onChanged(); + } else { + limitExprBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000080; + return this; + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 9; + */ + public Builder clearLimitExpr() { + if (limitExprBuilder_ == null) { + limitExpr_ = null; + onChanged(); + } else { + limitExprBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000080); + return this; + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 9; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.Builder getLimitExprBuilder() { + bitField0_ |= 0x00000080; + onChanged(); + return getLimitExprFieldBuilder().getBuilder(); + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 9; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitExprOrBuilder getLimitExprOrBuilder() { + if (limitExprBuilder_ != null) { + return limitExprBuilder_.getMessageOrBuilder(); + } else { + return limitExpr_ == null ? + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.getDefaultInstance() : limitExpr_; + } + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 9; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr, com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.LimitExprOrBuilder> + getLimitExprFieldBuilder() { + if (limitExprBuilder_ == null) { + limitExprBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr, com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.LimitExprOrBuilder>( + getLimitExpr(), + getParentForChildren(), + isClean()); + limitExpr_ = null; + } + return limitExprBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Crud.Update) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Crud.Update) + private static final com.mysql.cj.x.protobuf.MysqlxCrud.Update DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxCrud.Update(); + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.Update getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Update parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Update(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Update getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface DeleteOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Crud.Delete) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** collection to change 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return Whether the collection field is set. + */ + boolean hasCollection(); + /** + * 
+     ** collection to change 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return The collection. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Collection getCollection(); + /** + * 
+     ** collection to change 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder getCollectionOrBuilder(); + + /** + * 
+     ** data model that the operations refer to 
+     *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 2; + * @return Whether the dataModel field is set. + */ + boolean hasDataModel(); + /** + * 
+     ** data model that the operations refer to 
+     *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 2; + * @return The dataModel. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.DataModel getDataModel(); + + /** + * 
+     ** filter expression to match rows that the operations will apply on 
+     *
+ * + * optional .Mysqlx.Expr.Expr criteria = 3; + * @return Whether the criteria field is set. + */ + boolean hasCriteria(); + /** + * 
+     ** filter expression to match rows that the operations will apply on 
+     *
+ * + * optional .Mysqlx.Expr.Expr criteria = 3; + * @return The criteria. + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Expr getCriteria(); + /** + * 
+     ** filter expression to match rows that the operations will apply on 
+     *
+ * + * optional .Mysqlx.Expr.Expr criteria = 3; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getCriteriaOrBuilder(); + + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.Limit limit = 4; + * @return Whether the limit field is set. + */ + boolean hasLimit(); + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.Limit limit = 4; + * @return The limit. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Limit getLimit(); + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.Limit limit = 4; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.LimitOrBuilder getLimitOrBuilder(); + + /** + * 
+     ** specifies order of matched rows 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + java.util.List + getOrderList(); + /** + * 
+     ** specifies order of matched rows 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Order getOrder(int index); + /** + * 
+     ** specifies order of matched rows 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + int getOrderCount(); + /** + * 
+     ** specifies order of matched rows 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + java.util.List + getOrderOrBuilderList(); + /** + * 
+     ** specifies order of matched rows 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.OrderOrBuilder getOrderOrBuilder( + int index); + + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + java.util.List + getArgsList(); + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getArgs(int index); + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + int getArgsCount(); + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + java.util.List + getArgsOrBuilderList(); + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getArgsOrBuilder( + int index); + + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 7; + * @return Whether the limitExpr field is set. + */ + boolean hasLimitExpr(); + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 7; + * @return The limitExpr. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr getLimitExpr(); + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 7; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExprOrBuilder getLimitExprOrBuilder(); + } + /** + * 
+   **
+   *Delete documents/rows from a Collection/Table
+   *@returns @ref Mysqlx::Resultset
+   *
+ * + * Protobuf type {@code Mysqlx.Crud.Delete} + */ + public static final class Delete extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Crud.Delete) + DeleteOrBuilder { + private static final long serialVersionUID = 0L; + // Use Delete.newBuilder() to construct. + private Delete(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Delete() { + dataModel_ = 1; + order_ = java.util.Collections.emptyList(); + args_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Delete(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Delete( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) != 0)) { + subBuilder = collection_.toBuilder(); + } + collection_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Collection.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(collection_); + collection_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 16: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.DataModel value = com.mysql.cj.x.protobuf.MysqlxCrud.DataModel.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(2, rawValue); + } else { + bitField0_ |= 0x00000002; + dataModel_ = rawValue; + } + break; + } + case 26: { + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) != 0)) { + subBuilder = criteria_.toBuilder(); + } + criteria_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.Expr.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(criteria_); + criteria_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 34: { + com.mysql.cj.x.protobuf.MysqlxCrud.Limit.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) != 0)) { + subBuilder = limit_.toBuilder(); + } + limit_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Limit.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(limit_); + limit_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + break; + } + case 42: { + if (!((mutable_bitField0_ & 0x00000010) != 0)) { + order_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000010; + } + order_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Order.PARSER, extensionRegistry)); + break; + } + case 50: { + if (!((mutable_bitField0_ & 0x00000020) != 0)) { + args_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000020; + } + args_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.PARSER, extensionRegistry)); + break; + } + case 58: { + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.Builder subBuilder = null; + if (((bitField0_ & 0x00000010) != 0)) { + subBuilder = limitExpr_.toBuilder(); + } + limitExpr_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(limitExpr_); + limitExpr_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000010; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000010) != 0)) { + order_ = java.util.Collections.unmodifiableList(order_); + } + if (((mutable_bitField0_ & 0x00000020) != 0)) { + args_ = java.util.Collections.unmodifiableList(args_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Delete_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Delete_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.Delete.class, com.mysql.cj.x.protobuf.MysqlxCrud.Delete.Builder.class); + } + + private int bitField0_; + public static final int COLLECTION_FIELD_NUMBER = 1; + private com.mysql.cj.x.protobuf.MysqlxCrud.Collection collection_; + /** + * 
+     ** collection to change 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return Whether the collection field is set. + */ + public boolean hasCollection() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** collection to change 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return The collection. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection getCollection() { + return collection_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } + /** + * 
+     ** collection to change 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder getCollectionOrBuilder() { + return collection_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } + + public static final int DATA_MODEL_FIELD_NUMBER = 2; + private int dataModel_; + /** + * 
+     ** data model that the operations refer to 
+     *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 2; + * @return Whether the dataModel field is set. + */ + public boolean hasDataModel() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** data model that the operations refer to 
+     *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 2; + * @return The dataModel. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.DataModel getDataModel() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.DataModel result = com.mysql.cj.x.protobuf.MysqlxCrud.DataModel.valueOf(dataModel_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.DataModel.DOCUMENT : result; + } + + public static final int CRITERIA_FIELD_NUMBER = 3; + private com.mysql.cj.x.protobuf.MysqlxExpr.Expr criteria_; + /** + * 
+     ** filter expression to match rows that the operations will apply on 
+     *
+ * + * optional .Mysqlx.Expr.Expr criteria = 3; + * @return Whether the criteria field is set. + */ + public boolean hasCriteria() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+     ** filter expression to match rows that the operations will apply on 
+     *
+ * + * optional .Mysqlx.Expr.Expr criteria = 3; + * @return The criteria. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getCriteria() { + return criteria_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : criteria_; + } + /** + * 
+     ** filter expression to match rows that the operations will apply on 
+     *
+ * + * optional .Mysqlx.Expr.Expr criteria = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getCriteriaOrBuilder() { + return criteria_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : criteria_; + } + + public static final int LIMIT_FIELD_NUMBER = 4; + private com.mysql.cj.x.protobuf.MysqlxCrud.Limit limit_; + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.Limit limit = 4; + * @return Whether the limit field is set. + */ + public boolean hasLimit() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.Limit limit = 4; + * @return The limit. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Limit getLimit() { + return limit_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Limit.getDefaultInstance() : limit_; + } + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.Limit limit = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitOrBuilder getLimitOrBuilder() { + return limit_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Limit.getDefaultInstance() : limit_; + } + + public static final int ORDER_FIELD_NUMBER = 5; + private java.util.List order_; + /** + * 
+     ** specifies order of matched rows 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public java.util.List getOrderList() { + return order_; + } + /** + * 
+     ** specifies order of matched rows 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public java.util.List + getOrderOrBuilderList() { + return order_; + } + /** + * 
+     ** specifies order of matched rows 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public int getOrderCount() { + return order_.size(); + } + /** + * 
+     ** specifies order of matched rows 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Order getOrder(int index) { + return order_.get(index); + } + /** + * 
+     ** specifies order of matched rows 
+     *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.OrderOrBuilder getOrderOrBuilder( + int index) { + return order_.get(index); + } + + public static final int ARGS_FIELD_NUMBER = 6; + private java.util.List args_; + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public java.util.List getArgsList() { + return args_; + } + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public java.util.List + getArgsOrBuilderList() { + return args_; + } + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public int getArgsCount() { + return args_.size(); + } + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getArgs(int index) { + return args_.get(index); + } + /** + * 
+     ** values for parameters used in filter expression 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getArgsOrBuilder( + int index) { + return args_.get(index); + } + + public static final int LIMIT_EXPR_FIELD_NUMBER = 7; + private com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr limitExpr_; + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 7; + * @return Whether the limitExpr field is set. + */ + public boolean hasLimitExpr() { + return ((bitField0_ & 0x00000010) != 0); + } + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 7; + * @return The limitExpr. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr getLimitExpr() { + return limitExpr_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.getDefaultInstance() : limitExpr_; + } + /** + * 
+     ** limits the number of rows to match
+     *(user can set one of: limit, limit_expr) 
+     *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitExprOrBuilder getLimitExprOrBuilder() { + return limitExpr_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.getDefaultInstance() : limitExpr_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasCollection()) { + memoizedIsInitialized = 0; + return false; + } + if (!getCollection().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (hasCriteria()) { + if (!getCriteria().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasLimit()) { + if (!getLimit().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + for (int i = 0; i < getOrderCount(); i++) { + if (!getOrder(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + for (int i = 0; i < getArgsCount(); i++) { + if (!getArgs(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasLimitExpr()) { + if (!getLimitExpr().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeMessage(1, getCollection()); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeEnum(2, dataModel_); + } + if (((bitField0_ & 0x00000004) != 0)) { + output.writeMessage(3, getCriteria()); + } + if (((bitField0_ & 0x00000008) != 0)) { + output.writeMessage(4, getLimit()); + } + for (int i = 0; i < order_.size(); i++) { + output.writeMessage(5, order_.get(i)); + } + for (int i = 0; i < args_.size(); i++) { + output.writeMessage(6, args_.get(i)); + } + if (((bitField0_ & 0x00000010) != 0)) { + output.writeMessage(7, getLimitExpr()); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, getCollection()); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(2, dataModel_); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, getCriteria()); + } + if (((bitField0_ & 0x00000008) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, getLimit()); + } + for (int i = 0; i < order_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(5, order_.get(i)); + } + for (int i = 0; i < args_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(6, args_.get(i)); + } + if (((bitField0_ & 0x00000010) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(7, getLimitExpr()); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxCrud.Delete)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxCrud.Delete other = (com.mysql.cj.x.protobuf.MysqlxCrud.Delete) obj; + + if (hasCollection() != other.hasCollection()) return false; + if (hasCollection()) { + if (!getCollection() + .equals(other.getCollection())) return false; + } + if (hasDataModel() != other.hasDataModel()) return false; + if (hasDataModel()) { + if (dataModel_ != other.dataModel_) return false; + } + if (hasCriteria() != other.hasCriteria()) return false; + if (hasCriteria()) { + if (!getCriteria() + .equals(other.getCriteria())) return false; + } + if (hasLimit() != other.hasLimit()) return false; + if (hasLimit()) { + if (!getLimit() + .equals(other.getLimit())) return false; + } + if (!getOrderList() + .equals(other.getOrderList())) return false; + if (!getArgsList() + .equals(other.getArgsList())) return false; + if (hasLimitExpr() != other.hasLimitExpr()) return false; + if (hasLimitExpr()) { + if (!getLimitExpr() + .equals(other.getLimitExpr())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasCollection()) { + hash = (37 * hash) + COLLECTION_FIELD_NUMBER; + hash = (53 * hash) + getCollection().hashCode(); + } + if (hasDataModel()) { + hash = (37 * hash) + DATA_MODEL_FIELD_NUMBER; + hash = (53 * hash) + dataModel_; + } + if (hasCriteria()) { + hash = (37 * hash) + CRITERIA_FIELD_NUMBER; + hash = (53 * hash) + getCriteria().hashCode(); + } + if (hasLimit()) { + hash = (37 * hash) + LIMIT_FIELD_NUMBER; + hash = (53 * hash) + getLimit().hashCode(); + } + if (getOrderCount() > 0) { + hash = (37 * hash) + ORDER_FIELD_NUMBER; + hash = (53 * hash) + getOrderList().hashCode(); + } + if (getArgsCount() > 0) { + hash = (37 * hash) + ARGS_FIELD_NUMBER; + hash = (53 * hash) + getArgsList().hashCode(); + } + if (hasLimitExpr()) { + hash = (37 * hash) + LIMIT_EXPR_FIELD_NUMBER; + hash = (53 * hash) + getLimitExpr().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.Delete parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Delete parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Delete parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Delete parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Delete parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Delete parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Delete parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Delete parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Delete parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Delete parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Delete parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.Delete parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxCrud.Delete prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Delete documents/rows from a Collection/Table
+     *@returns @ref Mysqlx::Resultset
+     *
+ * + * Protobuf type {@code Mysqlx.Crud.Delete} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Crud.Delete) + com.mysql.cj.x.protobuf.MysqlxCrud.DeleteOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Delete_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Delete_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.Delete.class, com.mysql.cj.x.protobuf.MysqlxCrud.Delete.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxCrud.Delete.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getCollectionFieldBuilder(); + getCriteriaFieldBuilder(); + getLimitFieldBuilder(); + getOrderFieldBuilder(); + getArgsFieldBuilder(); + getLimitExprFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + if (collectionBuilder_ == null) { + collection_ = null; + } else { + collectionBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + dataModel_ = 1; + bitField0_ = (bitField0_ & ~0x00000002); + if (criteriaBuilder_ == null) { + criteria_ = null; + } else { + criteriaBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + if (limitBuilder_ == null) { + limit_ = null; + } else { + limitBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + if (orderBuilder_ == null) { + order_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000010); + } else { + orderBuilder_.clear(); + } + if (argsBuilder_ == null) { + args_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000020); + } else { + argsBuilder_.clear(); + } + if (limitExprBuilder_ == null) { + limitExpr_ = null; + } else { + limitExprBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000040); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_Delete_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Delete getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.Delete.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Delete build() { + com.mysql.cj.x.protobuf.MysqlxCrud.Delete result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Delete buildPartial() { + com.mysql.cj.x.protobuf.MysqlxCrud.Delete result = new com.mysql.cj.x.protobuf.MysqlxCrud.Delete(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + if (collectionBuilder_ == null) { + result.collection_ = collection_; + } else { + result.collection_ = collectionBuilder_.build(); + } + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + to_bitField0_ |= 0x00000002; + } + result.dataModel_ = dataModel_; + if (((from_bitField0_ & 0x00000004) != 0)) { + if (criteriaBuilder_ == null) { + result.criteria_ = criteria_; + } else { + result.criteria_ = criteriaBuilder_.build(); + } + to_bitField0_ |= 0x00000004; + } + if (((from_bitField0_ & 0x00000008) != 0)) { + if (limitBuilder_ == null) { + result.limit_ = limit_; + } else { + result.limit_ = limitBuilder_.build(); + } + to_bitField0_ |= 0x00000008; + } + if (orderBuilder_ == null) { + if (((bitField0_ & 0x00000010) != 0)) { + order_ = java.util.Collections.unmodifiableList(order_); + bitField0_ = (bitField0_ & ~0x00000010); + } + result.order_ = order_; + } else { + result.order_ = orderBuilder_.build(); + } + if (argsBuilder_ == null) { + if (((bitField0_ & 0x00000020) != 0)) { + args_ = java.util.Collections.unmodifiableList(args_); + bitField0_ = (bitField0_ & ~0x00000020); + } + result.args_ = args_; + } else { + result.args_ = argsBuilder_.build(); + } + if (((from_bitField0_ & 0x00000040) != 0)) { + if (limitExprBuilder_ == null) { + result.limitExpr_ = limitExpr_; + } else { + result.limitExpr_ = limitExprBuilder_.build(); + } + to_bitField0_ |= 0x00000010; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxCrud.Delete) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxCrud.Delete)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxCrud.Delete other) { + if (other == com.mysql.cj.x.protobuf.MysqlxCrud.Delete.getDefaultInstance()) return this; + if (other.hasCollection()) { + mergeCollection(other.getCollection()); + } + if (other.hasDataModel()) { + setDataModel(other.getDataModel()); + } + if (other.hasCriteria()) { + mergeCriteria(other.getCriteria()); + } + if (other.hasLimit()) { + mergeLimit(other.getLimit()); + } + if (orderBuilder_ == null) { + if (!other.order_.isEmpty()) { + if (order_.isEmpty()) { + order_ = other.order_; + bitField0_ = (bitField0_ & ~0x00000010); + } else { + ensureOrderIsMutable(); + order_.addAll(other.order_); + } + onChanged(); + } + } else { + if (!other.order_.isEmpty()) { + if (orderBuilder_.isEmpty()) { + orderBuilder_.dispose(); + orderBuilder_ = null; + order_ = other.order_; + bitField0_ = (bitField0_ & ~0x00000010); + orderBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getOrderFieldBuilder() : null; + } else { + orderBuilder_.addAllMessages(other.order_); + } + } + } + if (argsBuilder_ == null) { + if (!other.args_.isEmpty()) { + if (args_.isEmpty()) { + args_ = other.args_; + bitField0_ = (bitField0_ & ~0x00000020); + } else { + ensureArgsIsMutable(); + args_.addAll(other.args_); + } + onChanged(); + } + } else { + if (!other.args_.isEmpty()) { + if (argsBuilder_.isEmpty()) { + argsBuilder_.dispose(); + argsBuilder_ = null; + args_ = other.args_; + bitField0_ = (bitField0_ & ~0x00000020); + argsBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getArgsFieldBuilder() : null; + } else { + argsBuilder_.addAllMessages(other.args_); + } + } + } + if (other.hasLimitExpr()) { + mergeLimitExpr(other.getLimitExpr()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasCollection()) { + return false; + } + if (!getCollection().isInitialized()) { + return false; + } + if (hasCriteria()) { + if (!getCriteria().isInitialized()) { + return false; + } + } + if (hasLimit()) { + if (!getLimit().isInitialized()) { + return false; + } + } + for (int i = 0; i < getOrderCount(); i++) { + if (!getOrder(i).isInitialized()) { + return false; + } + } + for (int i = 0; i < getArgsCount(); i++) { + if (!getArgs(i).isInitialized()) { + return false; + } + } + if (hasLimitExpr()) { + if (!getLimitExpr().isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxCrud.Delete parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxCrud.Delete) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private com.mysql.cj.x.protobuf.MysqlxCrud.Collection collection_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Collection, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder> collectionBuilder_; + /** + * 
+       ** collection to change 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return Whether the collection field is set. + */ + public boolean hasCollection() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** collection to change 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return The collection. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection getCollection() { + if (collectionBuilder_ == null) { + return collection_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } else { + return collectionBuilder_.getMessage(); + } + } + /** + * 
+       ** collection to change 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public Builder setCollection(com.mysql.cj.x.protobuf.MysqlxCrud.Collection value) { + if (collectionBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + collection_ = value; + onChanged(); + } else { + collectionBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** collection to change 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public Builder setCollection( + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder builderForValue) { + if (collectionBuilder_ == null) { + collection_ = builderForValue.build(); + onChanged(); + } else { + collectionBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** collection to change 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public Builder mergeCollection(com.mysql.cj.x.protobuf.MysqlxCrud.Collection value) { + if (collectionBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0) && + collection_ != null && + collection_ != com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance()) { + collection_ = + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.newBuilder(collection_).mergeFrom(value).buildPartial(); + } else { + collection_ = value; + } + onChanged(); + } else { + collectionBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** collection to change 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public Builder clearCollection() { + if (collectionBuilder_ == null) { + collection_ = null; + onChanged(); + } else { + collectionBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + /** + * 
+       ** collection to change 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder getCollectionBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getCollectionFieldBuilder().getBuilder(); + } + /** + * 
+       ** collection to change 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder getCollectionOrBuilder() { + if (collectionBuilder_ != null) { + return collectionBuilder_.getMessageOrBuilder(); + } else { + return collection_ == null ? + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } + } + /** + * 
+       ** collection to change 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Collection, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder> + getCollectionFieldBuilder() { + if (collectionBuilder_ == null) { + collectionBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Collection, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder>( + getCollection(), + getParentForChildren(), + isClean()); + collection_ = null; + } + return collectionBuilder_; + } + + private int dataModel_ = 1; + /** + * 
+       ** data model that the operations refer to 
+       *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 2; + * @return Whether the dataModel field is set. + */ + public boolean hasDataModel() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** data model that the operations refer to 
+       *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 2; + * @return The dataModel. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.DataModel getDataModel() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.DataModel result = com.mysql.cj.x.protobuf.MysqlxCrud.DataModel.valueOf(dataModel_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.DataModel.DOCUMENT : result; + } + /** + * 
+       ** data model that the operations refer to 
+       *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 2; + * @param value The dataModel to set. + * @return This builder for chaining. + */ + public Builder setDataModel(com.mysql.cj.x.protobuf.MysqlxCrud.DataModel value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + dataModel_ = value.getNumber(); + onChanged(); + return this; + } + /** + * 
+       ** data model that the operations refer to 
+       *
+ * + * optional .Mysqlx.Crud.DataModel data_model = 2; + * @return This builder for chaining. + */ + public Builder clearDataModel() { + bitField0_ = (bitField0_ & ~0x00000002); + dataModel_ = 1; + onChanged(); + return this; + } + + private com.mysql.cj.x.protobuf.MysqlxExpr.Expr criteria_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> criteriaBuilder_; + /** + * 
+       ** filter expression to match rows that the operations will apply on 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 3; + * @return Whether the criteria field is set. + */ + public boolean hasCriteria() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+       ** filter expression to match rows that the operations will apply on 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 3; + * @return The criteria. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getCriteria() { + if (criteriaBuilder_ == null) { + return criteria_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : criteria_; + } else { + return criteriaBuilder_.getMessage(); + } + } + /** + * 
+       ** filter expression to match rows that the operations will apply on 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 3; + */ + public Builder setCriteria(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (criteriaBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + criteria_ = value; + onChanged(); + } else { + criteriaBuilder_.setMessage(value); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * 
+       ** filter expression to match rows that the operations will apply on 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 3; + */ + public Builder setCriteria( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (criteriaBuilder_ == null) { + criteria_ = builderForValue.build(); + onChanged(); + } else { + criteriaBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * 
+       ** filter expression to match rows that the operations will apply on 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 3; + */ + public Builder mergeCriteria(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (criteriaBuilder_ == null) { + if (((bitField0_ & 0x00000004) != 0) && + criteria_ != null && + criteria_ != com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance()) { + criteria_ = + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.newBuilder(criteria_).mergeFrom(value).buildPartial(); + } else { + criteria_ = value; + } + onChanged(); + } else { + criteriaBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * 
+       ** filter expression to match rows that the operations will apply on 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 3; + */ + public Builder clearCriteria() { + if (criteriaBuilder_ == null) { + criteria_ = null; + onChanged(); + } else { + criteriaBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + /** + * 
+       ** filter expression to match rows that the operations will apply on 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder getCriteriaBuilder() { + bitField0_ |= 0x00000004; + onChanged(); + return getCriteriaFieldBuilder().getBuilder(); + } + /** + * 
+       ** filter expression to match rows that the operations will apply on 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getCriteriaOrBuilder() { + if (criteriaBuilder_ != null) { + return criteriaBuilder_.getMessageOrBuilder(); + } else { + return criteria_ == null ? + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : criteria_; + } + } + /** + * 
+       ** filter expression to match rows that the operations will apply on 
+       *
+ * + * optional .Mysqlx.Expr.Expr criteria = 3; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> + getCriteriaFieldBuilder() { + if (criteriaBuilder_ == null) { + criteriaBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder>( + getCriteria(), + getParentForChildren(), + isClean()); + criteria_ = null; + } + return criteriaBuilder_; + } + + private com.mysql.cj.x.protobuf.MysqlxCrud.Limit limit_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Limit, com.mysql.cj.x.protobuf.MysqlxCrud.Limit.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.LimitOrBuilder> limitBuilder_; + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 4; + * @return Whether the limit field is set. + */ + public boolean hasLimit() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 4; + * @return The limit. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Limit getLimit() { + if (limitBuilder_ == null) { + return limit_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Limit.getDefaultInstance() : limit_; + } else { + return limitBuilder_.getMessage(); + } + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 4; + */ + public Builder setLimit(com.mysql.cj.x.protobuf.MysqlxCrud.Limit value) { + if (limitBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + limit_ = value; + onChanged(); + } else { + limitBuilder_.setMessage(value); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 4; + */ + public Builder setLimit( + com.mysql.cj.x.protobuf.MysqlxCrud.Limit.Builder builderForValue) { + if (limitBuilder_ == null) { + limit_ = builderForValue.build(); + onChanged(); + } else { + limitBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 4; + */ + public Builder mergeLimit(com.mysql.cj.x.protobuf.MysqlxCrud.Limit value) { + if (limitBuilder_ == null) { + if (((bitField0_ & 0x00000008) != 0) && + limit_ != null && + limit_ != com.mysql.cj.x.protobuf.MysqlxCrud.Limit.getDefaultInstance()) { + limit_ = + com.mysql.cj.x.protobuf.MysqlxCrud.Limit.newBuilder(limit_).mergeFrom(value).buildPartial(); + } else { + limit_ = value; + } + onChanged(); + } else { + limitBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 4; + */ + public Builder clearLimit() { + if (limitBuilder_ == null) { + limit_ = null; + onChanged(); + } else { + limitBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Limit.Builder getLimitBuilder() { + bitField0_ |= 0x00000008; + onChanged(); + return getLimitFieldBuilder().getBuilder(); + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitOrBuilder getLimitOrBuilder() { + if (limitBuilder_ != null) { + return limitBuilder_.getMessageOrBuilder(); + } else { + return limit_ == null ? + com.mysql.cj.x.protobuf.MysqlxCrud.Limit.getDefaultInstance() : limit_; + } + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.Limit limit = 4; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Limit, com.mysql.cj.x.protobuf.MysqlxCrud.Limit.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.LimitOrBuilder> + getLimitFieldBuilder() { + if (limitBuilder_ == null) { + limitBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Limit, com.mysql.cj.x.protobuf.MysqlxCrud.Limit.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.LimitOrBuilder>( + getLimit(), + getParentForChildren(), + isClean()); + limit_ = null; + } + return limitBuilder_; + } + + private java.util.List order_ = + java.util.Collections.emptyList(); + private void ensureOrderIsMutable() { + if (!((bitField0_ & 0x00000010) != 0)) { + order_ = new java.util.ArrayList(order_); + bitField0_ |= 0x00000010; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Order, com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.OrderOrBuilder> orderBuilder_; + + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public java.util.List getOrderList() { + if (orderBuilder_ == null) { + return java.util.Collections.unmodifiableList(order_); + } else { + return orderBuilder_.getMessageList(); + } + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public int getOrderCount() { + if (orderBuilder_ == null) { + return order_.size(); + } else { + return orderBuilder_.getCount(); + } + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Order getOrder(int index) { + if (orderBuilder_ == null) { + return order_.get(index); + } else { + return orderBuilder_.getMessage(index); + } + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public Builder setOrder( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Order value) { + if (orderBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureOrderIsMutable(); + order_.set(index, value); + onChanged(); + } else { + orderBuilder_.setMessage(index, value); + } + return this; + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public Builder setOrder( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder builderForValue) { + if (orderBuilder_ == null) { + ensureOrderIsMutable(); + order_.set(index, builderForValue.build()); + onChanged(); + } else { + orderBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public Builder addOrder(com.mysql.cj.x.protobuf.MysqlxCrud.Order value) { + if (orderBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureOrderIsMutable(); + order_.add(value); + onChanged(); + } else { + orderBuilder_.addMessage(value); + } + return this; + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public Builder addOrder( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Order value) { + if (orderBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureOrderIsMutable(); + order_.add(index, value); + onChanged(); + } else { + orderBuilder_.addMessage(index, value); + } + return this; + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public Builder addOrder( + com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder builderForValue) { + if (orderBuilder_ == null) { + ensureOrderIsMutable(); + order_.add(builderForValue.build()); + onChanged(); + } else { + orderBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public Builder addOrder( + int index, com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder builderForValue) { + if (orderBuilder_ == null) { + ensureOrderIsMutable(); + order_.add(index, builderForValue.build()); + onChanged(); + } else { + orderBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public Builder addAllOrder( + java.lang.Iterable values) { + if (orderBuilder_ == null) { + ensureOrderIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, order_); + onChanged(); + } else { + orderBuilder_.addAllMessages(values); + } + return this; + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public Builder clearOrder() { + if (orderBuilder_ == null) { + order_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000010); + onChanged(); + } else { + orderBuilder_.clear(); + } + return this; + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public Builder removeOrder(int index) { + if (orderBuilder_ == null) { + ensureOrderIsMutable(); + order_.remove(index); + onChanged(); + } else { + orderBuilder_.remove(index); + } + return this; + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder getOrderBuilder( + int index) { + return getOrderFieldBuilder().getBuilder(index); + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.OrderOrBuilder getOrderOrBuilder( + int index) { + if (orderBuilder_ == null) { + return order_.get(index); } else { + return orderBuilder_.getMessageOrBuilder(index); + } + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public java.util.List + getOrderOrBuilderList() { + if (orderBuilder_ != null) { + return orderBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(order_); + } + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder addOrderBuilder() { + return getOrderFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxCrud.Order.getDefaultInstance()); + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder addOrderBuilder( + int index) { + return getOrderFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxCrud.Order.getDefaultInstance()); + } + /** + * 
+       ** specifies order of matched rows 
+       *
+ * + * repeated .Mysqlx.Crud.Order order = 5; + */ + public java.util.List + getOrderBuilderList() { + return getOrderFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Order, com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.OrderOrBuilder> + getOrderFieldBuilder() { + if (orderBuilder_ == null) { + orderBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Order, com.mysql.cj.x.protobuf.MysqlxCrud.Order.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.OrderOrBuilder>( + order_, + ((bitField0_ & 0x00000010) != 0), + getParentForChildren(), + isClean()); + order_ = null; + } + return orderBuilder_; + } + + private java.util.List args_ = + java.util.Collections.emptyList(); + private void ensureArgsIsMutable() { + if (!((bitField0_ & 0x00000020) != 0)) { + args_ = new java.util.ArrayList(args_); + bitField0_ |= 0x00000020; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder> argsBuilder_; + + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public java.util.List getArgsList() { + if (argsBuilder_ == null) { + return java.util.Collections.unmodifiableList(args_); + } else { + return argsBuilder_.getMessageList(); + } + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public int getArgsCount() { + if (argsBuilder_ == null) { + return args_.size(); + } else { + return argsBuilder_.getCount(); + } + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getArgs(int index) { + if (argsBuilder_ == null) { + return args_.get(index); + } else { + return argsBuilder_.getMessage(index); + } + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public Builder setArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value) { + if (argsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgsIsMutable(); + args_.set(index, value); + onChanged(); + } else { + argsBuilder_.setMessage(index, value); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public Builder setArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder builderForValue) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.set(index, builderForValue.build()); + onChanged(); + } else { + argsBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public Builder addArgs(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value) { + if (argsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgsIsMutable(); + args_.add(value); + onChanged(); + } else { + argsBuilder_.addMessage(value); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public Builder addArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value) { + if (argsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgsIsMutable(); + args_.add(index, value); + onChanged(); + } else { + argsBuilder_.addMessage(index, value); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public Builder addArgs( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder builderForValue) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.add(builderForValue.build()); + onChanged(); + } else { + argsBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public Builder addArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder builderForValue) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.add(index, builderForValue.build()); + onChanged(); + } else { + argsBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public Builder addAllArgs( + java.lang.Iterable values) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, args_); + onChanged(); + } else { + argsBuilder_.addAllMessages(values); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public Builder clearArgs() { + if (argsBuilder_ == null) { + args_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000020); + onChanged(); + } else { + argsBuilder_.clear(); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public Builder removeArgs(int index) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.remove(index); + onChanged(); + } else { + argsBuilder_.remove(index); + } + return this; + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder getArgsBuilder( + int index) { + return getArgsFieldBuilder().getBuilder(index); + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getArgsOrBuilder( + int index) { + if (argsBuilder_ == null) { + return args_.get(index); } else { + return argsBuilder_.getMessageOrBuilder(index); + } + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public java.util.List + getArgsOrBuilderList() { + if (argsBuilder_ != null) { + return argsBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(args_); + } + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder addArgsBuilder() { + return getArgsFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance()); + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder addArgsBuilder( + int index) { + return getArgsFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance()); + } + /** + * 
+       ** values for parameters used in filter expression 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar args = 6; + */ + public java.util.List + getArgsBuilderList() { + return getArgsFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder> + getArgsFieldBuilder() { + if (argsBuilder_ == null) { + argsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder>( + args_, + ((bitField0_ & 0x00000020) != 0), + getParentForChildren(), + isClean()); + args_ = null; + } + return argsBuilder_; + } + + private com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr limitExpr_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr, com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.LimitExprOrBuilder> limitExprBuilder_; + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 7; + * @return Whether the limitExpr field is set. + */ + public boolean hasLimitExpr() { + return ((bitField0_ & 0x00000040) != 0); + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 7; + * @return The limitExpr. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr getLimitExpr() { + if (limitExprBuilder_ == null) { + return limitExpr_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.getDefaultInstance() : limitExpr_; + } else { + return limitExprBuilder_.getMessage(); + } + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 7; + */ + public Builder setLimitExpr(com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr value) { + if (limitExprBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + limitExpr_ = value; + onChanged(); + } else { + limitExprBuilder_.setMessage(value); + } + bitField0_ |= 0x00000040; + return this; + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 7; + */ + public Builder setLimitExpr( + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.Builder builderForValue) { + if (limitExprBuilder_ == null) { + limitExpr_ = builderForValue.build(); + onChanged(); + } else { + limitExprBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000040; + return this; + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 7; + */ + public Builder mergeLimitExpr(com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr value) { + if (limitExprBuilder_ == null) { + if (((bitField0_ & 0x00000040) != 0) && + limitExpr_ != null && + limitExpr_ != com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.getDefaultInstance()) { + limitExpr_ = + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.newBuilder(limitExpr_).mergeFrom(value).buildPartial(); + } else { + limitExpr_ = value; + } + onChanged(); + } else { + limitExprBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000040; + return this; + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 7; + */ + public Builder clearLimitExpr() { + if (limitExprBuilder_ == null) { + limitExpr_ = null; + onChanged(); + } else { + limitExprBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000040); + return this; + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.Builder getLimitExprBuilder() { + bitField0_ |= 0x00000040; + onChanged(); + return getLimitExprFieldBuilder().getBuilder(); + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.LimitExprOrBuilder getLimitExprOrBuilder() { + if (limitExprBuilder_ != null) { + return limitExprBuilder_.getMessageOrBuilder(); + } else { + return limitExpr_ == null ? + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.getDefaultInstance() : limitExpr_; + } + } + /** + * 
+       ** limits the number of rows to match
+       *(user can set one of: limit, limit_expr) 
+       *
+ * + * optional .Mysqlx.Crud.LimitExpr limit_expr = 7; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr, com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.LimitExprOrBuilder> + getLimitExprFieldBuilder() { + if (limitExprBuilder_ == null) { + limitExprBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr, com.mysql.cj.x.protobuf.MysqlxCrud.LimitExpr.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.LimitExprOrBuilder>( + getLimitExpr(), + getParentForChildren(), + isClean()); + limitExpr_ = null; + } + return limitExprBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Crud.Delete) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Crud.Delete) + private static final com.mysql.cj.x.protobuf.MysqlxCrud.Delete DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxCrud.Delete(); + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.Delete getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Delete parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Delete(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.Delete getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface CreateViewOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Crud.CreateView) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** name of the VIEW object, which should be created 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return Whether the collection field is set. + */ + boolean hasCollection(); + /** + * 
+     ** name of the VIEW object, which should be created 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return The collection. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Collection getCollection(); + /** + * 
+     ** name of the VIEW object, which should be created 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder getCollectionOrBuilder(); + + /** + * 
+     ** user name of the definer, if the value isn't set then the definer
+     *is current user 
+     *
+ * + * optional string definer = 2; + * @return Whether the definer field is set. + */ + boolean hasDefiner(); + /** + * 
+     ** user name of the definer, if the value isn't set then the definer
+     *is current user 
+     *
+ * + * optional string definer = 2; + * @return The definer. + */ + java.lang.String getDefiner(); + /** + * 
+     ** user name of the definer, if the value isn't set then the definer
+     *is current user 
+     *
+ * + * optional string definer = 2; + * @return The bytes for definer. + */ + com.google.protobuf.ByteString + getDefinerBytes(); + + /** + * 
+     ** defines how MySQL Server processes the view 
+     *
+ * + * optional .Mysqlx.Crud.ViewAlgorithm algorithm = 3 [default = UNDEFINED]; + * @return Whether the algorithm field is set. + */ + boolean hasAlgorithm(); + /** + * 
+     ** defines how MySQL Server processes the view 
+     *
+ * + * optional .Mysqlx.Crud.ViewAlgorithm algorithm = 3 [default = UNDEFINED]; + * @return The algorithm. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm getAlgorithm(); + + /** + * 
+     ** defines the security context in which the view is going be executed 
+     *
+ * + * optional .Mysqlx.Crud.ViewSqlSecurity security = 4 [default = DEFINER]; + * @return Whether the security field is set. + */ + boolean hasSecurity(); + /** + * 
+     ** defines the security context in which the view is going be executed 
+     *
+ * + * optional .Mysqlx.Crud.ViewSqlSecurity security = 4 [default = DEFINER]; + * @return The security. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity getSecurity(); + + /** + * 
+     ** limits the write operations done on a VIEW 
+     *
+ * + * optional .Mysqlx.Crud.ViewCheckOption check = 5; + * @return Whether the check field is set. + */ + boolean hasCheck(); + /** + * 
+     ** limits the write operations done on a VIEW 
+     *
+ * + * optional .Mysqlx.Crud.ViewCheckOption check = 5; + * @return The check. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption getCheck(); + + /** + * 
+     ** defines the list of aliases for column names specified in `stmt` 
+     *
+ * + * repeated string column = 6; + * @return A list containing the column. + */ + java.util.List + getColumnList(); + /** + * 
+     ** defines the list of aliases for column names specified in `stmt` 
+     *
+ * + * repeated string column = 6; + * @return The count of column. + */ + int getColumnCount(); + /** + * 
+     ** defines the list of aliases for column names specified in `stmt` 
+     *
+ * + * repeated string column = 6; + * @param index The index of the element to return. + * @return The column at the given index. + */ + java.lang.String getColumn(int index); + /** + * 
+     ** defines the list of aliases for column names specified in `stmt` 
+     *
+ * + * repeated string column = 6; + * @param index The index of the value to return. + * @return The bytes of the column at the given index. + */ + com.google.protobuf.ByteString + getColumnBytes(int index); + + /** + * 
+     ** Mysqlx.Crud.Find message from which the SELECT statement
+     *is going to be build 
+     *
+ * + * required .Mysqlx.Crud.Find stmt = 7; + * @return Whether the stmt field is set. + */ + boolean hasStmt(); + /** + * 
+     ** Mysqlx.Crud.Find message from which the SELECT statement
+     *is going to be build 
+     *
+ * + * required .Mysqlx.Crud.Find stmt = 7; + * @return The stmt. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Find getStmt(); + /** + * 
+     ** Mysqlx.Crud.Find message from which the SELECT statement
+     *is going to be build 
+     *
+ * + * required .Mysqlx.Crud.Find stmt = 7; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.FindOrBuilder getStmtOrBuilder(); + + /** + * 
+     ** if true then suppress error when created view already exists;
+     *just replace it 
+     *
+ * + * optional bool replace_existing = 8 [default = false]; + * @return Whether the replaceExisting field is set. + */ + boolean hasReplaceExisting(); + /** + * 
+     ** if true then suppress error when created view already exists;
+     *just replace it 
+     *
+ * + * optional bool replace_existing = 8 [default = false]; + * @return The replaceExisting. + */ + boolean getReplaceExisting(); + } + /** + * 
+   **
+   *CreateView create view based on indicated @ref Mysqlx::Crud::Find message
+   *
+ * + * Protobuf type {@code Mysqlx.Crud.CreateView} + */ + public static final class CreateView extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Crud.CreateView) + CreateViewOrBuilder { + private static final long serialVersionUID = 0L; + // Use CreateView.newBuilder() to construct. + private CreateView(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private CreateView() { + definer_ = ""; + algorithm_ = 1; + security_ = 2; + check_ = 1; + column_ = com.google.protobuf.LazyStringArrayList.EMPTY; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new CreateView(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private CreateView( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) != 0)) { + subBuilder = collection_.toBuilder(); + } + collection_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Collection.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(collection_); + collection_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000002; + definer_ = bs; + break; + } + case 24: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm value = com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(3, rawValue); + } else { + bitField0_ |= 0x00000004; + algorithm_ = rawValue; + } + break; + } + case 32: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity value = com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(4, rawValue); + } else { + bitField0_ |= 0x00000008; + security_ = rawValue; + } + break; + } + case 40: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption value = com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(5, rawValue); + } else { + bitField0_ |= 0x00000010; + check_ = rawValue; + } + break; + } + case 50: { + com.google.protobuf.ByteString bs = input.readBytes(); + if (!((mutable_bitField0_ & 0x00000020) != 0)) { + column_ = new com.google.protobuf.LazyStringArrayList(); + mutable_bitField0_ |= 0x00000020; + } + column_.add(bs); + break; + } + case 58: { + com.mysql.cj.x.protobuf.MysqlxCrud.Find.Builder subBuilder = null; + if (((bitField0_ & 0x00000020) != 0)) { + subBuilder = stmt_.toBuilder(); + } + stmt_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Find.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(stmt_); + stmt_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000020; + break; + } + case 64: { + bitField0_ |= 0x00000040; + replaceExisting_ = input.readBool(); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000020) != 0)) { + column_ = column_.getUnmodifiableView(); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_CreateView_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_CreateView_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.CreateView.class, com.mysql.cj.x.protobuf.MysqlxCrud.CreateView.Builder.class); + } + + private int bitField0_; + public static final int COLLECTION_FIELD_NUMBER = 1; + private com.mysql.cj.x.protobuf.MysqlxCrud.Collection collection_; + /** + * 
+     ** name of the VIEW object, which should be created 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return Whether the collection field is set. + */ + public boolean hasCollection() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** name of the VIEW object, which should be created 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return The collection. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection getCollection() { + return collection_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } + /** + * 
+     ** name of the VIEW object, which should be created 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder getCollectionOrBuilder() { + return collection_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } + + public static final int DEFINER_FIELD_NUMBER = 2; + private volatile java.lang.Object definer_; + /** + * 
+     ** user name of the definer, if the value isn't set then the definer
+     *is current user 
+     *
+ * + * optional string definer = 2; + * @return Whether the definer field is set. + */ + public boolean hasDefiner() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** user name of the definer, if the value isn't set then the definer
+     *is current user 
+     *
+ * + * optional string definer = 2; + * @return The definer. + */ + public java.lang.String getDefiner() { + java.lang.Object ref = definer_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + definer_ = s; + } + return s; + } + } + /** + * 
+     ** user name of the definer, if the value isn't set then the definer
+     *is current user 
+     *
+ * + * optional string definer = 2; + * @return The bytes for definer. + */ + public com.google.protobuf.ByteString + getDefinerBytes() { + java.lang.Object ref = definer_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + definer_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int ALGORITHM_FIELD_NUMBER = 3; + private int algorithm_; + /** + * 
+     ** defines how MySQL Server processes the view 
+     *
+ * + * optional .Mysqlx.Crud.ViewAlgorithm algorithm = 3 [default = UNDEFINED]; + * @return Whether the algorithm field is set. + */ + public boolean hasAlgorithm() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+     ** defines how MySQL Server processes the view 
+     *
+ * + * optional .Mysqlx.Crud.ViewAlgorithm algorithm = 3 [default = UNDEFINED]; + * @return The algorithm. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm getAlgorithm() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm result = com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm.valueOf(algorithm_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm.UNDEFINED : result; + } + + public static final int SECURITY_FIELD_NUMBER = 4; + private int security_; + /** + * 
+     ** defines the security context in which the view is going be executed 
+     *
+ * + * optional .Mysqlx.Crud.ViewSqlSecurity security = 4 [default = DEFINER]; + * @return Whether the security field is set. + */ + public boolean hasSecurity() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * 
+     ** defines the security context in which the view is going be executed 
+     *
+ * + * optional .Mysqlx.Crud.ViewSqlSecurity security = 4 [default = DEFINER]; + * @return The security. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity getSecurity() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity result = com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity.valueOf(security_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity.DEFINER : result; + } + + public static final int CHECK_FIELD_NUMBER = 5; + private int check_; + /** + * 
+     ** limits the write operations done on a VIEW 
+     *
+ * + * optional .Mysqlx.Crud.ViewCheckOption check = 5; + * @return Whether the check field is set. + */ + public boolean hasCheck() { + return ((bitField0_ & 0x00000010) != 0); + } + /** + * 
+     ** limits the write operations done on a VIEW 
+     *
+ * + * optional .Mysqlx.Crud.ViewCheckOption check = 5; + * @return The check. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption getCheck() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption result = com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption.valueOf(check_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption.LOCAL : result; + } + + public static final int COLUMN_FIELD_NUMBER = 6; + private com.google.protobuf.LazyStringList column_; + /** + * 
+     ** defines the list of aliases for column names specified in `stmt` 
+     *
+ * + * repeated string column = 6; + * @return A list containing the column. + */ + public com.google.protobuf.ProtocolStringList + getColumnList() { + return column_; + } + /** + * 
+     ** defines the list of aliases for column names specified in `stmt` 
+     *
+ * + * repeated string column = 6; + * @return The count of column. + */ + public int getColumnCount() { + return column_.size(); + } + /** + * 
+     ** defines the list of aliases for column names specified in `stmt` 
+     *
+ * + * repeated string column = 6; + * @param index The index of the element to return. + * @return The column at the given index. + */ + public java.lang.String getColumn(int index) { + return column_.get(index); + } + /** + * 
+     ** defines the list of aliases for column names specified in `stmt` 
+     *
+ * + * repeated string column = 6; + * @param index The index of the value to return. + * @return The bytes of the column at the given index. + */ + public com.google.protobuf.ByteString + getColumnBytes(int index) { + return column_.getByteString(index); + } + + public static final int STMT_FIELD_NUMBER = 7; + private com.mysql.cj.x.protobuf.MysqlxCrud.Find stmt_; + /** + * 
+     ** Mysqlx.Crud.Find message from which the SELECT statement
+     *is going to be build 
+     *
+ * + * required .Mysqlx.Crud.Find stmt = 7; + * @return Whether the stmt field is set. + */ + public boolean hasStmt() { + return ((bitField0_ & 0x00000020) != 0); + } + /** + * 
+     ** Mysqlx.Crud.Find message from which the SELECT statement
+     *is going to be build 
+     *
+ * + * required .Mysqlx.Crud.Find stmt = 7; + * @return The stmt. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Find getStmt() { + return stmt_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Find.getDefaultInstance() : stmt_; + } + /** + * 
+     ** Mysqlx.Crud.Find message from which the SELECT statement
+     *is going to be build 
+     *
+ * + * required .Mysqlx.Crud.Find stmt = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.FindOrBuilder getStmtOrBuilder() { + return stmt_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Find.getDefaultInstance() : stmt_; + } + + public static final int REPLACE_EXISTING_FIELD_NUMBER = 8; + private boolean replaceExisting_; + /** + * 
+     ** if true then suppress error when created view already exists;
+     *just replace it 
+     *
+ * + * optional bool replace_existing = 8 [default = false]; + * @return Whether the replaceExisting field is set. + */ + public boolean hasReplaceExisting() { + return ((bitField0_ & 0x00000040) != 0); + } + /** + * 
+     ** if true then suppress error when created view already exists;
+     *just replace it 
+     *
+ * + * optional bool replace_existing = 8 [default = false]; + * @return The replaceExisting. + */ + public boolean getReplaceExisting() { + return replaceExisting_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasCollection()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasStmt()) { + memoizedIsInitialized = 0; + return false; + } + if (!getCollection().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (!getStmt().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeMessage(1, getCollection()); + } + if (((bitField0_ & 0x00000002) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, definer_); + } + if (((bitField0_ & 0x00000004) != 0)) { + output.writeEnum(3, algorithm_); + } + if (((bitField0_ & 0x00000008) != 0)) { + output.writeEnum(4, security_); + } + if (((bitField0_ & 0x00000010) != 0)) { + output.writeEnum(5, check_); + } + for (int i = 0; i < column_.size(); i++) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 6, column_.getRaw(i)); + } + if (((bitField0_ & 0x00000020) != 0)) { + output.writeMessage(7, getStmt()); + } + if (((bitField0_ & 0x00000040) != 0)) { + output.writeBool(8, replaceExisting_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, getCollection()); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, definer_); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(3, algorithm_); + } + if (((bitField0_ & 0x00000008) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(4, security_); + } + if (((bitField0_ & 0x00000010) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(5, check_); + } + { + int dataSize = 0; + for (int i = 0; i < column_.size(); i++) { + dataSize += computeStringSizeNoTag(column_.getRaw(i)); + } + size += dataSize; + size += 1 * getColumnList().size(); + } + if (((bitField0_ & 0x00000020) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(7, getStmt()); + } + if (((bitField0_ & 0x00000040) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(8, replaceExisting_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxCrud.CreateView)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxCrud.CreateView other = (com.mysql.cj.x.protobuf.MysqlxCrud.CreateView) obj; + + if (hasCollection() != other.hasCollection()) return false; + if (hasCollection()) { + if (!getCollection() + .equals(other.getCollection())) return false; + } + if (hasDefiner() != other.hasDefiner()) return false; + if (hasDefiner()) { + if (!getDefiner() + .equals(other.getDefiner())) return false; + } + if (hasAlgorithm() != other.hasAlgorithm()) return false; + if (hasAlgorithm()) { + if (algorithm_ != other.algorithm_) return false; + } + if (hasSecurity() != other.hasSecurity()) return false; + if (hasSecurity()) { + if (security_ != other.security_) return false; + } + if (hasCheck() != other.hasCheck()) return false; + if (hasCheck()) { + if (check_ != other.check_) return false; + } + if (!getColumnList() + .equals(other.getColumnList())) return false; + if (hasStmt() != other.hasStmt()) return false; + if (hasStmt()) { + if (!getStmt() + .equals(other.getStmt())) return false; + } + if (hasReplaceExisting() != other.hasReplaceExisting()) return false; + if (hasReplaceExisting()) { + if (getReplaceExisting() + != other.getReplaceExisting()) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasCollection()) { + hash = (37 * hash) + COLLECTION_FIELD_NUMBER; + hash = (53 * hash) + getCollection().hashCode(); + } + if (hasDefiner()) { + hash = (37 * hash) + DEFINER_FIELD_NUMBER; + hash = (53 * hash) + getDefiner().hashCode(); + } + if (hasAlgorithm()) { + hash = (37 * hash) + ALGORITHM_FIELD_NUMBER; + hash = (53 * hash) + algorithm_; + } + if (hasSecurity()) { + hash = (37 * hash) + SECURITY_FIELD_NUMBER; + hash = (53 * hash) + security_; + } + if (hasCheck()) { + hash = (37 * hash) + CHECK_FIELD_NUMBER; + hash = (53 * hash) + check_; + } + if (getColumnCount() > 0) { + hash = (37 * hash) + COLUMN_FIELD_NUMBER; + hash = (53 * hash) + getColumnList().hashCode(); + } + if (hasStmt()) { + hash = (37 * hash) + STMT_FIELD_NUMBER; + hash = (53 * hash) + getStmt().hashCode(); + } + if (hasReplaceExisting()) { + hash = (37 * hash) + REPLACE_EXISTING_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getReplaceExisting()); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.CreateView parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.CreateView parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.CreateView parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.CreateView parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.CreateView parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.CreateView parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.CreateView parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.CreateView parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.CreateView parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.CreateView parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.CreateView parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.CreateView parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxCrud.CreateView prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *CreateView create view based on indicated @ref Mysqlx::Crud::Find message
+     *
+ * + * Protobuf type {@code Mysqlx.Crud.CreateView} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Crud.CreateView) + com.mysql.cj.x.protobuf.MysqlxCrud.CreateViewOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_CreateView_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_CreateView_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.CreateView.class, com.mysql.cj.x.protobuf.MysqlxCrud.CreateView.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxCrud.CreateView.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getCollectionFieldBuilder(); + getStmtFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + if (collectionBuilder_ == null) { + collection_ = null; + } else { + collectionBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + definer_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + algorithm_ = 1; + bitField0_ = (bitField0_ & ~0x00000004); + security_ = 2; + bitField0_ = (bitField0_ & ~0x00000008); + check_ = 1; + bitField0_ = (bitField0_ & ~0x00000010); + column_ = com.google.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000020); + if (stmtBuilder_ == null) { + stmt_ = null; + } else { + stmtBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000040); + replaceExisting_ = false; + bitField0_ = (bitField0_ & ~0x00000080); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_CreateView_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.CreateView getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.CreateView.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.CreateView build() { + com.mysql.cj.x.protobuf.MysqlxCrud.CreateView result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.CreateView buildPartial() { + com.mysql.cj.x.protobuf.MysqlxCrud.CreateView result = new com.mysql.cj.x.protobuf.MysqlxCrud.CreateView(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + if (collectionBuilder_ == null) { + result.collection_ = collection_; + } else { + result.collection_ = collectionBuilder_.build(); + } + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + to_bitField0_ |= 0x00000002; + } + result.definer_ = definer_; + if (((from_bitField0_ & 0x00000004) != 0)) { + to_bitField0_ |= 0x00000004; + } + result.algorithm_ = algorithm_; + if (((from_bitField0_ & 0x00000008) != 0)) { + to_bitField0_ |= 0x00000008; + } + result.security_ = security_; + if (((from_bitField0_ & 0x00000010) != 0)) { + to_bitField0_ |= 0x00000010; + } + result.check_ = check_; + if (((bitField0_ & 0x00000020) != 0)) { + column_ = column_.getUnmodifiableView(); + bitField0_ = (bitField0_ & ~0x00000020); + } + result.column_ = column_; + if (((from_bitField0_ & 0x00000040) != 0)) { + if (stmtBuilder_ == null) { + result.stmt_ = stmt_; + } else { + result.stmt_ = stmtBuilder_.build(); + } + to_bitField0_ |= 0x00000020; + } + if (((from_bitField0_ & 0x00000080) != 0)) { + result.replaceExisting_ = replaceExisting_; + to_bitField0_ |= 0x00000040; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxCrud.CreateView) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxCrud.CreateView)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxCrud.CreateView other) { + if (other == com.mysql.cj.x.protobuf.MysqlxCrud.CreateView.getDefaultInstance()) return this; + if (other.hasCollection()) { + mergeCollection(other.getCollection()); + } + if (other.hasDefiner()) { + bitField0_ |= 0x00000002; + definer_ = other.definer_; + onChanged(); + } + if (other.hasAlgorithm()) { + setAlgorithm(other.getAlgorithm()); + } + if (other.hasSecurity()) { + setSecurity(other.getSecurity()); + } + if (other.hasCheck()) { + setCheck(other.getCheck()); + } + if (!other.column_.isEmpty()) { + if (column_.isEmpty()) { + column_ = other.column_; + bitField0_ = (bitField0_ & ~0x00000020); + } else { + ensureColumnIsMutable(); + column_.addAll(other.column_); + } + onChanged(); + } + if (other.hasStmt()) { + mergeStmt(other.getStmt()); + } + if (other.hasReplaceExisting()) { + setReplaceExisting(other.getReplaceExisting()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasCollection()) { + return false; + } + if (!hasStmt()) { + return false; + } + if (!getCollection().isInitialized()) { + return false; + } + if (!getStmt().isInitialized()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxCrud.CreateView parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxCrud.CreateView) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private com.mysql.cj.x.protobuf.MysqlxCrud.Collection collection_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Collection, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder> collectionBuilder_; + /** + * 
+       ** name of the VIEW object, which should be created 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return Whether the collection field is set. + */ + public boolean hasCollection() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** name of the VIEW object, which should be created 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return The collection. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection getCollection() { + if (collectionBuilder_ == null) { + return collection_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } else { + return collectionBuilder_.getMessage(); + } + } + /** + * 
+       ** name of the VIEW object, which should be created 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public Builder setCollection(com.mysql.cj.x.protobuf.MysqlxCrud.Collection value) { + if (collectionBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + collection_ = value; + onChanged(); + } else { + collectionBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** name of the VIEW object, which should be created 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public Builder setCollection( + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder builderForValue) { + if (collectionBuilder_ == null) { + collection_ = builderForValue.build(); + onChanged(); + } else { + collectionBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** name of the VIEW object, which should be created 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public Builder mergeCollection(com.mysql.cj.x.protobuf.MysqlxCrud.Collection value) { + if (collectionBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0) && + collection_ != null && + collection_ != com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance()) { + collection_ = + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.newBuilder(collection_).mergeFrom(value).buildPartial(); + } else { + collection_ = value; + } + onChanged(); + } else { + collectionBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** name of the VIEW object, which should be created 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public Builder clearCollection() { + if (collectionBuilder_ == null) { + collection_ = null; + onChanged(); + } else { + collectionBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + /** + * 
+       ** name of the VIEW object, which should be created 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder getCollectionBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getCollectionFieldBuilder().getBuilder(); + } + /** + * 
+       ** name of the VIEW object, which should be created 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder getCollectionOrBuilder() { + if (collectionBuilder_ != null) { + return collectionBuilder_.getMessageOrBuilder(); + } else { + return collection_ == null ? + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } + } + /** + * 
+       ** name of the VIEW object, which should be created 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Collection, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder> + getCollectionFieldBuilder() { + if (collectionBuilder_ == null) { + collectionBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Collection, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder>( + getCollection(), + getParentForChildren(), + isClean()); + collection_ = null; + } + return collectionBuilder_; + } + + private java.lang.Object definer_ = ""; + /** + * 
+       ** user name of the definer, if the value isn't set then the definer
+       *is current user 
+       *
+ * + * optional string definer = 2; + * @return Whether the definer field is set. + */ + public boolean hasDefiner() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** user name of the definer, if the value isn't set then the definer
+       *is current user 
+       *
+ * + * optional string definer = 2; + * @return The definer. + */ + public java.lang.String getDefiner() { + java.lang.Object ref = definer_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + definer_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * 
+       ** user name of the definer, if the value isn't set then the definer
+       *is current user 
+       *
+ * + * optional string definer = 2; + * @return The bytes for definer. + */ + public com.google.protobuf.ByteString + getDefinerBytes() { + java.lang.Object ref = definer_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + definer_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * 
+       ** user name of the definer, if the value isn't set then the definer
+       *is current user 
+       *
+ * + * optional string definer = 2; + * @param value The definer to set. + * @return This builder for chaining. + */ + public Builder setDefiner( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + definer_ = value; + onChanged(); + return this; + } + /** + * 
+       ** user name of the definer, if the value isn't set then the definer
+       *is current user 
+       *
+ * + * optional string definer = 2; + * @return This builder for chaining. + */ + public Builder clearDefiner() { + bitField0_ = (bitField0_ & ~0x00000002); + definer_ = getDefaultInstance().getDefiner(); + onChanged(); + return this; + } + /** + * 
+       ** user name of the definer, if the value isn't set then the definer
+       *is current user 
+       *
+ * + * optional string definer = 2; + * @param value The bytes for definer to set. + * @return This builder for chaining. + */ + public Builder setDefinerBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + definer_ = value; + onChanged(); + return this; + } + + private int algorithm_ = 1; + /** + * 
+       ** defines how MySQL Server processes the view 
+       *
+ * + * optional .Mysqlx.Crud.ViewAlgorithm algorithm = 3 [default = UNDEFINED]; + * @return Whether the algorithm field is set. + */ + public boolean hasAlgorithm() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+       ** defines how MySQL Server processes the view 
+       *
+ * + * optional .Mysqlx.Crud.ViewAlgorithm algorithm = 3 [default = UNDEFINED]; + * @return The algorithm. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm getAlgorithm() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm result = com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm.valueOf(algorithm_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm.UNDEFINED : result; + } + /** + * 
+       ** defines how MySQL Server processes the view 
+       *
+ * + * optional .Mysqlx.Crud.ViewAlgorithm algorithm = 3 [default = UNDEFINED]; + * @param value The algorithm to set. + * @return This builder for chaining. + */ + public Builder setAlgorithm(com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + algorithm_ = value.getNumber(); + onChanged(); + return this; + } + /** + * 
+       ** defines how MySQL Server processes the view 
+       *
+ * + * optional .Mysqlx.Crud.ViewAlgorithm algorithm = 3 [default = UNDEFINED]; + * @return This builder for chaining. + */ + public Builder clearAlgorithm() { + bitField0_ = (bitField0_ & ~0x00000004); + algorithm_ = 1; + onChanged(); + return this; + } + + private int security_ = 2; + /** + * 
+       ** defines the security context in which the view is going be executed 
+       *
+ * + * optional .Mysqlx.Crud.ViewSqlSecurity security = 4 [default = DEFINER]; + * @return Whether the security field is set. + */ + public boolean hasSecurity() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * 
+       ** defines the security context in which the view is going be executed 
+       *
+ * + * optional .Mysqlx.Crud.ViewSqlSecurity security = 4 [default = DEFINER]; + * @return The security. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity getSecurity() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity result = com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity.valueOf(security_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity.DEFINER : result; + } + /** + * 
+       ** defines the security context in which the view is going be executed 
+       *
+ * + * optional .Mysqlx.Crud.ViewSqlSecurity security = 4 [default = DEFINER]; + * @param value The security to set. + * @return This builder for chaining. + */ + public Builder setSecurity(com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + security_ = value.getNumber(); + onChanged(); + return this; + } + /** + * 
+       ** defines the security context in which the view is going be executed 
+       *
+ * + * optional .Mysqlx.Crud.ViewSqlSecurity security = 4 [default = DEFINER]; + * @return This builder for chaining. + */ + public Builder clearSecurity() { + bitField0_ = (bitField0_ & ~0x00000008); + security_ = 2; + onChanged(); + return this; + } + + private int check_ = 1; + /** + * 
+       ** limits the write operations done on a VIEW 
+       *
+ * + * optional .Mysqlx.Crud.ViewCheckOption check = 5; + * @return Whether the check field is set. + */ + public boolean hasCheck() { + return ((bitField0_ & 0x00000010) != 0); + } + /** + * 
+       ** limits the write operations done on a VIEW 
+       *
+ * + * optional .Mysqlx.Crud.ViewCheckOption check = 5; + * @return The check. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption getCheck() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption result = com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption.valueOf(check_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption.LOCAL : result; + } + /** + * 
+       ** limits the write operations done on a VIEW 
+       *
+ * + * optional .Mysqlx.Crud.ViewCheckOption check = 5; + * @param value The check to set. + * @return This builder for chaining. + */ + public Builder setCheck(com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000010; + check_ = value.getNumber(); + onChanged(); + return this; + } + /** + * 
+       ** limits the write operations done on a VIEW 
+       *
+ * + * optional .Mysqlx.Crud.ViewCheckOption check = 5; + * @return This builder for chaining. + */ + public Builder clearCheck() { + bitField0_ = (bitField0_ & ~0x00000010); + check_ = 1; + onChanged(); + return this; + } + + private com.google.protobuf.LazyStringList column_ = com.google.protobuf.LazyStringArrayList.EMPTY; + private void ensureColumnIsMutable() { + if (!((bitField0_ & 0x00000020) != 0)) { + column_ = new com.google.protobuf.LazyStringArrayList(column_); + bitField0_ |= 0x00000020; + } + } + /** + * 
+       ** defines the list of aliases for column names specified in `stmt` 
+       *
+ * + * repeated string column = 6; + * @return A list containing the column. + */ + public com.google.protobuf.ProtocolStringList + getColumnList() { + return column_.getUnmodifiableView(); + } + /** + * 
+       ** defines the list of aliases for column names specified in `stmt` 
+       *
+ * + * repeated string column = 6; + * @return The count of column. + */ + public int getColumnCount() { + return column_.size(); + } + /** + * 
+       ** defines the list of aliases for column names specified in `stmt` 
+       *
+ * + * repeated string column = 6; + * @param index The index of the element to return. + * @return The column at the given index. + */ + public java.lang.String getColumn(int index) { + return column_.get(index); + } + /** + * 
+       ** defines the list of aliases for column names specified in `stmt` 
+       *
+ * + * repeated string column = 6; + * @param index The index of the value to return. + * @return The bytes of the column at the given index. + */ + public com.google.protobuf.ByteString + getColumnBytes(int index) { + return column_.getByteString(index); + } + /** + * 
+       ** defines the list of aliases for column names specified in `stmt` 
+       *
+ * + * repeated string column = 6; + * @param index The index to set the value at. + * @param value The column to set. + * @return This builder for chaining. + */ + public Builder setColumn( + int index, java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureColumnIsMutable(); + column_.set(index, value); + onChanged(); + return this; + } + /** + * 
+       ** defines the list of aliases for column names specified in `stmt` 
+       *
+ * + * repeated string column = 6; + * @param value The column to add. + * @return This builder for chaining. + */ + public Builder addColumn( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureColumnIsMutable(); + column_.add(value); + onChanged(); + return this; + } + /** + * 
+       ** defines the list of aliases for column names specified in `stmt` 
+       *
+ * + * repeated string column = 6; + * @param values The column to add. + * @return This builder for chaining. + */ + public Builder addAllColumn( + java.lang.Iterable values) { + ensureColumnIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, column_); + onChanged(); + return this; + } + /** + * 
+       ** defines the list of aliases for column names specified in `stmt` 
+       *
+ * + * repeated string column = 6; + * @return This builder for chaining. + */ + public Builder clearColumn() { + column_ = com.google.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000020); + onChanged(); + return this; + } + /** + * 
+       ** defines the list of aliases for column names specified in `stmt` 
+       *
+ * + * repeated string column = 6; + * @param value The bytes of the column to add. + * @return This builder for chaining. + */ + public Builder addColumnBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + ensureColumnIsMutable(); + column_.add(value); + onChanged(); + return this; + } + + private com.mysql.cj.x.protobuf.MysqlxCrud.Find stmt_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Find, com.mysql.cj.x.protobuf.MysqlxCrud.Find.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.FindOrBuilder> stmtBuilder_; + /** + * 
+       ** Mysqlx.Crud.Find message from which the SELECT statement
+       *is going to be build 
+       *
+ * + * required .Mysqlx.Crud.Find stmt = 7; + * @return Whether the stmt field is set. + */ + public boolean hasStmt() { + return ((bitField0_ & 0x00000040) != 0); + } + /** + * 
+       ** Mysqlx.Crud.Find message from which the SELECT statement
+       *is going to be build 
+       *
+ * + * required .Mysqlx.Crud.Find stmt = 7; + * @return The stmt. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Find getStmt() { + if (stmtBuilder_ == null) { + return stmt_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Find.getDefaultInstance() : stmt_; + } else { + return stmtBuilder_.getMessage(); + } + } + /** + * 
+       ** Mysqlx.Crud.Find message from which the SELECT statement
+       *is going to be build 
+       *
+ * + * required .Mysqlx.Crud.Find stmt = 7; + */ + public Builder setStmt(com.mysql.cj.x.protobuf.MysqlxCrud.Find value) { + if (stmtBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + stmt_ = value; + onChanged(); + } else { + stmtBuilder_.setMessage(value); + } + bitField0_ |= 0x00000040; + return this; + } + /** + * 
+       ** Mysqlx.Crud.Find message from which the SELECT statement
+       *is going to be build 
+       *
+ * + * required .Mysqlx.Crud.Find stmt = 7; + */ + public Builder setStmt( + com.mysql.cj.x.protobuf.MysqlxCrud.Find.Builder builderForValue) { + if (stmtBuilder_ == null) { + stmt_ = builderForValue.build(); + onChanged(); + } else { + stmtBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000040; + return this; + } + /** + * 
+       ** Mysqlx.Crud.Find message from which the SELECT statement
+       *is going to be build 
+       *
+ * + * required .Mysqlx.Crud.Find stmt = 7; + */ + public Builder mergeStmt(com.mysql.cj.x.protobuf.MysqlxCrud.Find value) { + if (stmtBuilder_ == null) { + if (((bitField0_ & 0x00000040) != 0) && + stmt_ != null && + stmt_ != com.mysql.cj.x.protobuf.MysqlxCrud.Find.getDefaultInstance()) { + stmt_ = + com.mysql.cj.x.protobuf.MysqlxCrud.Find.newBuilder(stmt_).mergeFrom(value).buildPartial(); + } else { + stmt_ = value; + } + onChanged(); + } else { + stmtBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000040; + return this; + } + /** + * 
+       ** Mysqlx.Crud.Find message from which the SELECT statement
+       *is going to be build 
+       *
+ * + * required .Mysqlx.Crud.Find stmt = 7; + */ + public Builder clearStmt() { + if (stmtBuilder_ == null) { + stmt_ = null; + onChanged(); + } else { + stmtBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000040); + return this; + } + /** + * 
+       ** Mysqlx.Crud.Find message from which the SELECT statement
+       *is going to be build 
+       *
+ * + * required .Mysqlx.Crud.Find stmt = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Find.Builder getStmtBuilder() { + bitField0_ |= 0x00000040; + onChanged(); + return getStmtFieldBuilder().getBuilder(); + } + /** + * 
+       ** Mysqlx.Crud.Find message from which the SELECT statement
+       *is going to be build 
+       *
+ * + * required .Mysqlx.Crud.Find stmt = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.FindOrBuilder getStmtOrBuilder() { + if (stmtBuilder_ != null) { + return stmtBuilder_.getMessageOrBuilder(); + } else { + return stmt_ == null ? + com.mysql.cj.x.protobuf.MysqlxCrud.Find.getDefaultInstance() : stmt_; + } + } + /** + * 
+       ** Mysqlx.Crud.Find message from which the SELECT statement
+       *is going to be build 
+       *
+ * + * required .Mysqlx.Crud.Find stmt = 7; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Find, com.mysql.cj.x.protobuf.MysqlxCrud.Find.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.FindOrBuilder> + getStmtFieldBuilder() { + if (stmtBuilder_ == null) { + stmtBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Find, com.mysql.cj.x.protobuf.MysqlxCrud.Find.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.FindOrBuilder>( + getStmt(), + getParentForChildren(), + isClean()); + stmt_ = null; + } + return stmtBuilder_; + } + + private boolean replaceExisting_ ; + /** + * 
+       ** if true then suppress error when created view already exists;
+       *just replace it 
+       *
+ * + * optional bool replace_existing = 8 [default = false]; + * @return Whether the replaceExisting field is set. + */ + public boolean hasReplaceExisting() { + return ((bitField0_ & 0x00000080) != 0); + } + /** + * 
+       ** if true then suppress error when created view already exists;
+       *just replace it 
+       *
+ * + * optional bool replace_existing = 8 [default = false]; + * @return The replaceExisting. + */ + public boolean getReplaceExisting() { + return replaceExisting_; + } + /** + * 
+       ** if true then suppress error when created view already exists;
+       *just replace it 
+       *
+ * + * optional bool replace_existing = 8 [default = false]; + * @param value The replaceExisting to set. + * @return This builder for chaining. + */ + public Builder setReplaceExisting(boolean value) { + bitField0_ |= 0x00000080; + replaceExisting_ = value; + onChanged(); + return this; + } + /** + * 
+       ** if true then suppress error when created view already exists;
+       *just replace it 
+       *
+ * + * optional bool replace_existing = 8 [default = false]; + * @return This builder for chaining. + */ + public Builder clearReplaceExisting() { + bitField0_ = (bitField0_ & ~0x00000080); + replaceExisting_ = false; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Crud.CreateView) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Crud.CreateView) + private static final com.mysql.cj.x.protobuf.MysqlxCrud.CreateView DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxCrud.CreateView(); + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.CreateView getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public CreateView parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new CreateView(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.CreateView getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ModifyViewOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Crud.ModifyView) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** name of the VIEW object, which should be modified 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return Whether the collection field is set. + */ + boolean hasCollection(); + /** + * 
+     ** name of the VIEW object, which should be modified 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return The collection. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Collection getCollection(); + /** + * 
+     ** name of the VIEW object, which should be modified 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder getCollectionOrBuilder(); + + /** + * 
+     ** user name of the definer,
+     *if the value isn't set then the definer is current user 
+     *
+ * + * optional string definer = 2; + * @return Whether the definer field is set. + */ + boolean hasDefiner(); + /** + * 
+     ** user name of the definer,
+     *if the value isn't set then the definer is current user 
+     *
+ * + * optional string definer = 2; + * @return The definer. + */ + java.lang.String getDefiner(); + /** + * 
+     ** user name of the definer,
+     *if the value isn't set then the definer is current user 
+     *
+ * + * optional string definer = 2; + * @return The bytes for definer. + */ + com.google.protobuf.ByteString + getDefinerBytes(); + + /** + * 
+     ** defined how MySQL Server processes the view 
+     *
+ * + * optional .Mysqlx.Crud.ViewAlgorithm algorithm = 3; + * @return Whether the algorithm field is set. + */ + boolean hasAlgorithm(); + /** + * 
+     ** defined how MySQL Server processes the view 
+     *
+ * + * optional .Mysqlx.Crud.ViewAlgorithm algorithm = 3; + * @return The algorithm. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm getAlgorithm(); + + /** + * 
+     ** defines the security context in which the view is going be executed 
+     *
+ * + * optional .Mysqlx.Crud.ViewSqlSecurity security = 4; + * @return Whether the security field is set. + */ + boolean hasSecurity(); + /** + * 
+     ** defines the security context in which the view is going be executed 
+     *
+ * + * optional .Mysqlx.Crud.ViewSqlSecurity security = 4; + * @return The security. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity getSecurity(); + + /** + * 
+     ** limits the write operations done on a VIEW 
+     *
+ * + * optional .Mysqlx.Crud.ViewCheckOption check = 5; + * @return Whether the check field is set. + */ + boolean hasCheck(); + /** + * 
+     ** limits the write operations done on a VIEW 
+     *
+ * + * optional .Mysqlx.Crud.ViewCheckOption check = 5; + * @return The check. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption getCheck(); + + /** + * 
+     ** defines the list of aliases for column names specified in `stmt` 
+     *
+ * + * repeated string column = 6; + * @return A list containing the column. + */ + java.util.List + getColumnList(); + /** + * 
+     ** defines the list of aliases for column names specified in `stmt` 
+     *
+ * + * repeated string column = 6; + * @return The count of column. + */ + int getColumnCount(); + /** + * 
+     ** defines the list of aliases for column names specified in `stmt` 
+     *
+ * + * repeated string column = 6; + * @param index The index of the element to return. + * @return The column at the given index. + */ + java.lang.String getColumn(int index); + /** + * 
+     ** defines the list of aliases for column names specified in `stmt` 
+     *
+ * + * repeated string column = 6; + * @param index The index of the value to return. + * @return The bytes of the column at the given index. + */ + com.google.protobuf.ByteString + getColumnBytes(int index); + + /** + * 
+     ** Mysqlx.Crud.Find message from which the SELECT statement
+     *is going to be build 
+     *
+ * + * optional .Mysqlx.Crud.Find stmt = 7; + * @return Whether the stmt field is set. + */ + boolean hasStmt(); + /** + * 
+     ** Mysqlx.Crud.Find message from which the SELECT statement
+     *is going to be build 
+     *
+ * + * optional .Mysqlx.Crud.Find stmt = 7; + * @return The stmt. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Find getStmt(); + /** + * 
+     ** Mysqlx.Crud.Find message from which the SELECT statement
+     *is going to be build 
+     *
+ * + * optional .Mysqlx.Crud.Find stmt = 7; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.FindOrBuilder getStmtOrBuilder(); + } + /** + * 
+   **
+   *ModifyView modify existing view based on indicated
+   *@ref Mysqlx::Crud::Find message
+   *
+ * + * Protobuf type {@code Mysqlx.Crud.ModifyView} + */ + public static final class ModifyView extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Crud.ModifyView) + ModifyViewOrBuilder { + private static final long serialVersionUID = 0L; + // Use ModifyView.newBuilder() to construct. + private ModifyView(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private ModifyView() { + definer_ = ""; + algorithm_ = 1; + security_ = 1; + check_ = 1; + column_ = com.google.protobuf.LazyStringArrayList.EMPTY; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new ModifyView(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private ModifyView( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) != 0)) { + subBuilder = collection_.toBuilder(); + } + collection_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Collection.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(collection_); + collection_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000002; + definer_ = bs; + break; + } + case 24: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm value = com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(3, rawValue); + } else { + bitField0_ |= 0x00000004; + algorithm_ = rawValue; + } + break; + } + case 32: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity value = com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(4, rawValue); + } else { + bitField0_ |= 0x00000008; + security_ = rawValue; + } + break; + } + case 40: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption value = com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(5, rawValue); + } else { + bitField0_ |= 0x00000010; + check_ = rawValue; + } + break; + } + case 50: { + com.google.protobuf.ByteString bs = input.readBytes(); + if (!((mutable_bitField0_ & 0x00000020) != 0)) { + column_ = new com.google.protobuf.LazyStringArrayList(); + mutable_bitField0_ |= 0x00000020; + } + column_.add(bs); + break; + } + case 58: { + com.mysql.cj.x.protobuf.MysqlxCrud.Find.Builder subBuilder = null; + if (((bitField0_ & 0x00000020) != 0)) { + subBuilder = stmt_.toBuilder(); + } + stmt_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Find.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(stmt_); + stmt_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000020; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000020) != 0)) { + column_ = column_.getUnmodifiableView(); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_ModifyView_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_ModifyView_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView.class, com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView.Builder.class); + } + + private int bitField0_; + public static final int COLLECTION_FIELD_NUMBER = 1; + private com.mysql.cj.x.protobuf.MysqlxCrud.Collection collection_; + /** + * 
+     ** name of the VIEW object, which should be modified 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return Whether the collection field is set. + */ + public boolean hasCollection() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** name of the VIEW object, which should be modified 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return The collection. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection getCollection() { + return collection_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } + /** + * 
+     ** name of the VIEW object, which should be modified 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder getCollectionOrBuilder() { + return collection_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } + + public static final int DEFINER_FIELD_NUMBER = 2; + private volatile java.lang.Object definer_; + /** + * 
+     ** user name of the definer,
+     *if the value isn't set then the definer is current user 
+     *
+ * + * optional string definer = 2; + * @return Whether the definer field is set. + */ + public boolean hasDefiner() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** user name of the definer,
+     *if the value isn't set then the definer is current user 
+     *
+ * + * optional string definer = 2; + * @return The definer. + */ + public java.lang.String getDefiner() { + java.lang.Object ref = definer_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + definer_ = s; + } + return s; + } + } + /** + * 
+     ** user name of the definer,
+     *if the value isn't set then the definer is current user 
+     *
+ * + * optional string definer = 2; + * @return The bytes for definer. + */ + public com.google.protobuf.ByteString + getDefinerBytes() { + java.lang.Object ref = definer_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + definer_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int ALGORITHM_FIELD_NUMBER = 3; + private int algorithm_; + /** + * 
+     ** defined how MySQL Server processes the view 
+     *
+ * + * optional .Mysqlx.Crud.ViewAlgorithm algorithm = 3; + * @return Whether the algorithm field is set. + */ + public boolean hasAlgorithm() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+     ** defined how MySQL Server processes the view 
+     *
+ * + * optional .Mysqlx.Crud.ViewAlgorithm algorithm = 3; + * @return The algorithm. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm getAlgorithm() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm result = com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm.valueOf(algorithm_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm.UNDEFINED : result; + } + + public static final int SECURITY_FIELD_NUMBER = 4; + private int security_; + /** + * 
+     ** defines the security context in which the view is going be executed 
+     *
+ * + * optional .Mysqlx.Crud.ViewSqlSecurity security = 4; + * @return Whether the security field is set. + */ + public boolean hasSecurity() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * 
+     ** defines the security context in which the view is going be executed 
+     *
+ * + * optional .Mysqlx.Crud.ViewSqlSecurity security = 4; + * @return The security. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity getSecurity() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity result = com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity.valueOf(security_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity.INVOKER : result; + } + + public static final int CHECK_FIELD_NUMBER = 5; + private int check_; + /** + * 
+     ** limits the write operations done on a VIEW 
+     *
+ * + * optional .Mysqlx.Crud.ViewCheckOption check = 5; + * @return Whether the check field is set. + */ + public boolean hasCheck() { + return ((bitField0_ & 0x00000010) != 0); + } + /** + * 
+     ** limits the write operations done on a VIEW 
+     *
+ * + * optional .Mysqlx.Crud.ViewCheckOption check = 5; + * @return The check. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption getCheck() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption result = com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption.valueOf(check_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption.LOCAL : result; + } + + public static final int COLUMN_FIELD_NUMBER = 6; + private com.google.protobuf.LazyStringList column_; + /** + * 
+     ** defines the list of aliases for column names specified in `stmt` 
+     *
+ * + * repeated string column = 6; + * @return A list containing the column. + */ + public com.google.protobuf.ProtocolStringList + getColumnList() { + return column_; + } + /** + * 
+     ** defines the list of aliases for column names specified in `stmt` 
+     *
+ * + * repeated string column = 6; + * @return The count of column. + */ + public int getColumnCount() { + return column_.size(); + } + /** + * 
+     ** defines the list of aliases for column names specified in `stmt` 
+     *
+ * + * repeated string column = 6; + * @param index The index of the element to return. + * @return The column at the given index. + */ + public java.lang.String getColumn(int index) { + return column_.get(index); + } + /** + * 
+     ** defines the list of aliases for column names specified in `stmt` 
+     *
+ * + * repeated string column = 6; + * @param index The index of the value to return. + * @return The bytes of the column at the given index. + */ + public com.google.protobuf.ByteString + getColumnBytes(int index) { + return column_.getByteString(index); + } + + public static final int STMT_FIELD_NUMBER = 7; + private com.mysql.cj.x.protobuf.MysqlxCrud.Find stmt_; + /** + * 
+     ** Mysqlx.Crud.Find message from which the SELECT statement
+     *is going to be build 
+     *
+ * + * optional .Mysqlx.Crud.Find stmt = 7; + * @return Whether the stmt field is set. + */ + public boolean hasStmt() { + return ((bitField0_ & 0x00000020) != 0); + } + /** + * 
+     ** Mysqlx.Crud.Find message from which the SELECT statement
+     *is going to be build 
+     *
+ * + * optional .Mysqlx.Crud.Find stmt = 7; + * @return The stmt. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Find getStmt() { + return stmt_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Find.getDefaultInstance() : stmt_; + } + /** + * 
+     ** Mysqlx.Crud.Find message from which the SELECT statement
+     *is going to be build 
+     *
+ * + * optional .Mysqlx.Crud.Find stmt = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.FindOrBuilder getStmtOrBuilder() { + return stmt_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Find.getDefaultInstance() : stmt_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasCollection()) { + memoizedIsInitialized = 0; + return false; + } + if (!getCollection().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + if (hasStmt()) { + if (!getStmt().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeMessage(1, getCollection()); + } + if (((bitField0_ & 0x00000002) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, definer_); + } + if (((bitField0_ & 0x00000004) != 0)) { + output.writeEnum(3, algorithm_); + } + if (((bitField0_ & 0x00000008) != 0)) { + output.writeEnum(4, security_); + } + if (((bitField0_ & 0x00000010) != 0)) { + output.writeEnum(5, check_); + } + for (int i = 0; i < column_.size(); i++) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 6, column_.getRaw(i)); + } + if (((bitField0_ & 0x00000020) != 0)) { + output.writeMessage(7, getStmt()); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, getCollection()); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, definer_); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(3, algorithm_); + } + if (((bitField0_ & 0x00000008) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(4, security_); + } + if (((bitField0_ & 0x00000010) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(5, check_); + } + { + int dataSize = 0; + for (int i = 0; i < column_.size(); i++) { + dataSize += computeStringSizeNoTag(column_.getRaw(i)); + } + size += dataSize; + size += 1 * getColumnList().size(); + } + if (((bitField0_ & 0x00000020) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(7, getStmt()); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView other = (com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView) obj; + + if (hasCollection() != other.hasCollection()) return false; + if (hasCollection()) { + if (!getCollection() + .equals(other.getCollection())) return false; + } + if (hasDefiner() != other.hasDefiner()) return false; + if (hasDefiner()) { + if (!getDefiner() + .equals(other.getDefiner())) return false; + } + if (hasAlgorithm() != other.hasAlgorithm()) return false; + if (hasAlgorithm()) { + if (algorithm_ != other.algorithm_) return false; + } + if (hasSecurity() != other.hasSecurity()) return false; + if (hasSecurity()) { + if (security_ != other.security_) return false; + } + if (hasCheck() != other.hasCheck()) return false; + if (hasCheck()) { + if (check_ != other.check_) return false; + } + if (!getColumnList() + .equals(other.getColumnList())) return false; + if (hasStmt() != other.hasStmt()) return false; + if (hasStmt()) { + if (!getStmt() + .equals(other.getStmt())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasCollection()) { + hash = (37 * hash) + COLLECTION_FIELD_NUMBER; + hash = (53 * hash) + getCollection().hashCode(); + } + if (hasDefiner()) { + hash = (37 * hash) + DEFINER_FIELD_NUMBER; + hash = (53 * hash) + getDefiner().hashCode(); + } + if (hasAlgorithm()) { + hash = (37 * hash) + ALGORITHM_FIELD_NUMBER; + hash = (53 * hash) + algorithm_; + } + if (hasSecurity()) { + hash = (37 * hash) + SECURITY_FIELD_NUMBER; + hash = (53 * hash) + security_; + } + if (hasCheck()) { + hash = (37 * hash) + CHECK_FIELD_NUMBER; + hash = (53 * hash) + check_; + } + if (getColumnCount() > 0) { + hash = (37 * hash) + COLUMN_FIELD_NUMBER; + hash = (53 * hash) + getColumnList().hashCode(); + } + if (hasStmt()) { + hash = (37 * hash) + STMT_FIELD_NUMBER; + hash = (53 * hash) + getStmt().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *ModifyView modify existing view based on indicated
+     *@ref Mysqlx::Crud::Find message
+     *
+ * + * Protobuf type {@code Mysqlx.Crud.ModifyView} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Crud.ModifyView) + com.mysql.cj.x.protobuf.MysqlxCrud.ModifyViewOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_ModifyView_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_ModifyView_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView.class, com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getCollectionFieldBuilder(); + getStmtFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + if (collectionBuilder_ == null) { + collection_ = null; + } else { + collectionBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + definer_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + algorithm_ = 1; + bitField0_ = (bitField0_ & ~0x00000004); + security_ = 1; + bitField0_ = (bitField0_ & ~0x00000008); + check_ = 1; + bitField0_ = (bitField0_ & ~0x00000010); + column_ = com.google.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000020); + if (stmtBuilder_ == null) { + stmt_ = null; + } else { + stmtBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000040); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_ModifyView_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView build() { + com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView buildPartial() { + com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView result = new com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + if (collectionBuilder_ == null) { + result.collection_ = collection_; + } else { + result.collection_ = collectionBuilder_.build(); + } + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + to_bitField0_ |= 0x00000002; + } + result.definer_ = definer_; + if (((from_bitField0_ & 0x00000004) != 0)) { + to_bitField0_ |= 0x00000004; + } + result.algorithm_ = algorithm_; + if (((from_bitField0_ & 0x00000008) != 0)) { + to_bitField0_ |= 0x00000008; + } + result.security_ = security_; + if (((from_bitField0_ & 0x00000010) != 0)) { + to_bitField0_ |= 0x00000010; + } + result.check_ = check_; + if (((bitField0_ & 0x00000020) != 0)) { + column_ = column_.getUnmodifiableView(); + bitField0_ = (bitField0_ & ~0x00000020); + } + result.column_ = column_; + if (((from_bitField0_ & 0x00000040) != 0)) { + if (stmtBuilder_ == null) { + result.stmt_ = stmt_; + } else { + result.stmt_ = stmtBuilder_.build(); + } + to_bitField0_ |= 0x00000020; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView other) { + if (other == com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView.getDefaultInstance()) return this; + if (other.hasCollection()) { + mergeCollection(other.getCollection()); + } + if (other.hasDefiner()) { + bitField0_ |= 0x00000002; + definer_ = other.definer_; + onChanged(); + } + if (other.hasAlgorithm()) { + setAlgorithm(other.getAlgorithm()); + } + if (other.hasSecurity()) { + setSecurity(other.getSecurity()); + } + if (other.hasCheck()) { + setCheck(other.getCheck()); + } + if (!other.column_.isEmpty()) { + if (column_.isEmpty()) { + column_ = other.column_; + bitField0_ = (bitField0_ & ~0x00000020); + } else { + ensureColumnIsMutable(); + column_.addAll(other.column_); + } + onChanged(); + } + if (other.hasStmt()) { + mergeStmt(other.getStmt()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasCollection()) { + return false; + } + if (!getCollection().isInitialized()) { + return false; + } + if (hasStmt()) { + if (!getStmt().isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private com.mysql.cj.x.protobuf.MysqlxCrud.Collection collection_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Collection, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder> collectionBuilder_; + /** + * 
+       ** name of the VIEW object, which should be modified 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return Whether the collection field is set. + */ + public boolean hasCollection() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** name of the VIEW object, which should be modified 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return The collection. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection getCollection() { + if (collectionBuilder_ == null) { + return collection_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } else { + return collectionBuilder_.getMessage(); + } + } + /** + * 
+       ** name of the VIEW object, which should be modified 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public Builder setCollection(com.mysql.cj.x.protobuf.MysqlxCrud.Collection value) { + if (collectionBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + collection_ = value; + onChanged(); + } else { + collectionBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** name of the VIEW object, which should be modified 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public Builder setCollection( + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder builderForValue) { + if (collectionBuilder_ == null) { + collection_ = builderForValue.build(); + onChanged(); + } else { + collectionBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** name of the VIEW object, which should be modified 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public Builder mergeCollection(com.mysql.cj.x.protobuf.MysqlxCrud.Collection value) { + if (collectionBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0) && + collection_ != null && + collection_ != com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance()) { + collection_ = + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.newBuilder(collection_).mergeFrom(value).buildPartial(); + } else { + collection_ = value; + } + onChanged(); + } else { + collectionBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** name of the VIEW object, which should be modified 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public Builder clearCollection() { + if (collectionBuilder_ == null) { + collection_ = null; + onChanged(); + } else { + collectionBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + /** + * 
+       ** name of the VIEW object, which should be modified 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder getCollectionBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getCollectionFieldBuilder().getBuilder(); + } + /** + * 
+       ** name of the VIEW object, which should be modified 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder getCollectionOrBuilder() { + if (collectionBuilder_ != null) { + return collectionBuilder_.getMessageOrBuilder(); + } else { + return collection_ == null ? + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } + } + /** + * 
+       ** name of the VIEW object, which should be modified 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Collection, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder> + getCollectionFieldBuilder() { + if (collectionBuilder_ == null) { + collectionBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Collection, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder>( + getCollection(), + getParentForChildren(), + isClean()); + collection_ = null; + } + return collectionBuilder_; + } + + private java.lang.Object definer_ = ""; + /** + * 
+       ** user name of the definer,
+       *if the value isn't set then the definer is current user 
+       *
+ * + * optional string definer = 2; + * @return Whether the definer field is set. + */ + public boolean hasDefiner() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** user name of the definer,
+       *if the value isn't set then the definer is current user 
+       *
+ * + * optional string definer = 2; + * @return The definer. + */ + public java.lang.String getDefiner() { + java.lang.Object ref = definer_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + definer_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * 
+       ** user name of the definer,
+       *if the value isn't set then the definer is current user 
+       *
+ * + * optional string definer = 2; + * @return The bytes for definer. + */ + public com.google.protobuf.ByteString + getDefinerBytes() { + java.lang.Object ref = definer_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + definer_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * 
+       ** user name of the definer,
+       *if the value isn't set then the definer is current user 
+       *
+ * + * optional string definer = 2; + * @param value The definer to set. + * @return This builder for chaining. + */ + public Builder setDefiner( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + definer_ = value; + onChanged(); + return this; + } + /** + * 
+       ** user name of the definer,
+       *if the value isn't set then the definer is current user 
+       *
+ * + * optional string definer = 2; + * @return This builder for chaining. + */ + public Builder clearDefiner() { + bitField0_ = (bitField0_ & ~0x00000002); + definer_ = getDefaultInstance().getDefiner(); + onChanged(); + return this; + } + /** + * 
+       ** user name of the definer,
+       *if the value isn't set then the definer is current user 
+       *
+ * + * optional string definer = 2; + * @param value The bytes for definer to set. + * @return This builder for chaining. + */ + public Builder setDefinerBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + definer_ = value; + onChanged(); + return this; + } + + private int algorithm_ = 1; + /** + * 
+       ** defined how MySQL Server processes the view 
+       *
+ * + * optional .Mysqlx.Crud.ViewAlgorithm algorithm = 3; + * @return Whether the algorithm field is set. + */ + public boolean hasAlgorithm() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+       ** defined how MySQL Server processes the view 
+       *
+ * + * optional .Mysqlx.Crud.ViewAlgorithm algorithm = 3; + * @return The algorithm. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm getAlgorithm() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm result = com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm.valueOf(algorithm_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm.UNDEFINED : result; + } + /** + * 
+       ** defined how MySQL Server processes the view 
+       *
+ * + * optional .Mysqlx.Crud.ViewAlgorithm algorithm = 3; + * @param value The algorithm to set. + * @return This builder for chaining. + */ + public Builder setAlgorithm(com.mysql.cj.x.protobuf.MysqlxCrud.ViewAlgorithm value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + algorithm_ = value.getNumber(); + onChanged(); + return this; + } + /** + * 
+       ** defined how MySQL Server processes the view 
+       *
+ * + * optional .Mysqlx.Crud.ViewAlgorithm algorithm = 3; + * @return This builder for chaining. + */ + public Builder clearAlgorithm() { + bitField0_ = (bitField0_ & ~0x00000004); + algorithm_ = 1; + onChanged(); + return this; + } + + private int security_ = 1; + /** + * 
+       ** defines the security context in which the view is going be executed 
+       *
+ * + * optional .Mysqlx.Crud.ViewSqlSecurity security = 4; + * @return Whether the security field is set. + */ + public boolean hasSecurity() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * 
+       ** defines the security context in which the view is going be executed 
+       *
+ * + * optional .Mysqlx.Crud.ViewSqlSecurity security = 4; + * @return The security. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity getSecurity() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity result = com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity.valueOf(security_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity.INVOKER : result; + } + /** + * 
+       ** defines the security context in which the view is going be executed 
+       *
+ * + * optional .Mysqlx.Crud.ViewSqlSecurity security = 4; + * @param value The security to set. + * @return This builder for chaining. + */ + public Builder setSecurity(com.mysql.cj.x.protobuf.MysqlxCrud.ViewSqlSecurity value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + security_ = value.getNumber(); + onChanged(); + return this; + } + /** + * 
+       ** defines the security context in which the view is going be executed 
+       *
+ * + * optional .Mysqlx.Crud.ViewSqlSecurity security = 4; + * @return This builder for chaining. + */ + public Builder clearSecurity() { + bitField0_ = (bitField0_ & ~0x00000008); + security_ = 1; + onChanged(); + return this; + } + + private int check_ = 1; + /** + * 
+       ** limits the write operations done on a VIEW 
+       *
+ * + * optional .Mysqlx.Crud.ViewCheckOption check = 5; + * @return Whether the check field is set. + */ + public boolean hasCheck() { + return ((bitField0_ & 0x00000010) != 0); + } + /** + * 
+       ** limits the write operations done on a VIEW 
+       *
+ * + * optional .Mysqlx.Crud.ViewCheckOption check = 5; + * @return The check. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption getCheck() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption result = com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption.valueOf(check_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption.LOCAL : result; + } + /** + * 
+       ** limits the write operations done on a VIEW 
+       *
+ * + * optional .Mysqlx.Crud.ViewCheckOption check = 5; + * @param value The check to set. + * @return This builder for chaining. + */ + public Builder setCheck(com.mysql.cj.x.protobuf.MysqlxCrud.ViewCheckOption value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000010; + check_ = value.getNumber(); + onChanged(); + return this; + } + /** + * 
+       ** limits the write operations done on a VIEW 
+       *
+ * + * optional .Mysqlx.Crud.ViewCheckOption check = 5; + * @return This builder for chaining. + */ + public Builder clearCheck() { + bitField0_ = (bitField0_ & ~0x00000010); + check_ = 1; + onChanged(); + return this; + } + + private com.google.protobuf.LazyStringList column_ = com.google.protobuf.LazyStringArrayList.EMPTY; + private void ensureColumnIsMutable() { + if (!((bitField0_ & 0x00000020) != 0)) { + column_ = new com.google.protobuf.LazyStringArrayList(column_); + bitField0_ |= 0x00000020; + } + } + /** + * 
+       ** defines the list of aliases for column names specified in `stmt` 
+       *
+ * + * repeated string column = 6; + * @return A list containing the column. + */ + public com.google.protobuf.ProtocolStringList + getColumnList() { + return column_.getUnmodifiableView(); + } + /** + * 
+       ** defines the list of aliases for column names specified in `stmt` 
+       *
+ * + * repeated string column = 6; + * @return The count of column. + */ + public int getColumnCount() { + return column_.size(); + } + /** + * 
+       ** defines the list of aliases for column names specified in `stmt` 
+       *
+ * + * repeated string column = 6; + * @param index The index of the element to return. + * @return The column at the given index. + */ + public java.lang.String getColumn(int index) { + return column_.get(index); + } + /** + * 
+       ** defines the list of aliases for column names specified in `stmt` 
+       *
+ * + * repeated string column = 6; + * @param index The index of the value to return. + * @return The bytes of the column at the given index. + */ + public com.google.protobuf.ByteString + getColumnBytes(int index) { + return column_.getByteString(index); + } + /** + * 
+       ** defines the list of aliases for column names specified in `stmt` 
+       *
+ * + * repeated string column = 6; + * @param index The index to set the value at. + * @param value The column to set. + * @return This builder for chaining. + */ + public Builder setColumn( + int index, java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureColumnIsMutable(); + column_.set(index, value); + onChanged(); + return this; + } + /** + * 
+       ** defines the list of aliases for column names specified in `stmt` 
+       *
+ * + * repeated string column = 6; + * @param value The column to add. + * @return This builder for chaining. + */ + public Builder addColumn( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + ensureColumnIsMutable(); + column_.add(value); + onChanged(); + return this; + } + /** + * 
+       ** defines the list of aliases for column names specified in `stmt` 
+       *
+ * + * repeated string column = 6; + * @param values The column to add. + * @return This builder for chaining. + */ + public Builder addAllColumn( + java.lang.Iterable values) { + ensureColumnIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, column_); + onChanged(); + return this; + } + /** + * 
+       ** defines the list of aliases for column names specified in `stmt` 
+       *
+ * + * repeated string column = 6; + * @return This builder for chaining. + */ + public Builder clearColumn() { + column_ = com.google.protobuf.LazyStringArrayList.EMPTY; + bitField0_ = (bitField0_ & ~0x00000020); + onChanged(); + return this; + } + /** + * 
+       ** defines the list of aliases for column names specified in `stmt` 
+       *
+ * + * repeated string column = 6; + * @param value The bytes of the column to add. + * @return This builder for chaining. + */ + public Builder addColumnBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + ensureColumnIsMutable(); + column_.add(value); + onChanged(); + return this; + } + + private com.mysql.cj.x.protobuf.MysqlxCrud.Find stmt_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Find, com.mysql.cj.x.protobuf.MysqlxCrud.Find.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.FindOrBuilder> stmtBuilder_; + /** + * 
+       ** Mysqlx.Crud.Find message from which the SELECT statement
+       *is going to be build 
+       *
+ * + * optional .Mysqlx.Crud.Find stmt = 7; + * @return Whether the stmt field is set. + */ + public boolean hasStmt() { + return ((bitField0_ & 0x00000040) != 0); + } + /** + * 
+       ** Mysqlx.Crud.Find message from which the SELECT statement
+       *is going to be build 
+       *
+ * + * optional .Mysqlx.Crud.Find stmt = 7; + * @return The stmt. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Find getStmt() { + if (stmtBuilder_ == null) { + return stmt_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Find.getDefaultInstance() : stmt_; + } else { + return stmtBuilder_.getMessage(); + } + } + /** + * 
+       ** Mysqlx.Crud.Find message from which the SELECT statement
+       *is going to be build 
+       *
+ * + * optional .Mysqlx.Crud.Find stmt = 7; + */ + public Builder setStmt(com.mysql.cj.x.protobuf.MysqlxCrud.Find value) { + if (stmtBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + stmt_ = value; + onChanged(); + } else { + stmtBuilder_.setMessage(value); + } + bitField0_ |= 0x00000040; + return this; + } + /** + * 
+       ** Mysqlx.Crud.Find message from which the SELECT statement
+       *is going to be build 
+       *
+ * + * optional .Mysqlx.Crud.Find stmt = 7; + */ + public Builder setStmt( + com.mysql.cj.x.protobuf.MysqlxCrud.Find.Builder builderForValue) { + if (stmtBuilder_ == null) { + stmt_ = builderForValue.build(); + onChanged(); + } else { + stmtBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000040; + return this; + } + /** + * 
+       ** Mysqlx.Crud.Find message from which the SELECT statement
+       *is going to be build 
+       *
+ * + * optional .Mysqlx.Crud.Find stmt = 7; + */ + public Builder mergeStmt(com.mysql.cj.x.protobuf.MysqlxCrud.Find value) { + if (stmtBuilder_ == null) { + if (((bitField0_ & 0x00000040) != 0) && + stmt_ != null && + stmt_ != com.mysql.cj.x.protobuf.MysqlxCrud.Find.getDefaultInstance()) { + stmt_ = + com.mysql.cj.x.protobuf.MysqlxCrud.Find.newBuilder(stmt_).mergeFrom(value).buildPartial(); + } else { + stmt_ = value; + } + onChanged(); + } else { + stmtBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000040; + return this; + } + /** + * 
+       ** Mysqlx.Crud.Find message from which the SELECT statement
+       *is going to be build 
+       *
+ * + * optional .Mysqlx.Crud.Find stmt = 7; + */ + public Builder clearStmt() { + if (stmtBuilder_ == null) { + stmt_ = null; + onChanged(); + } else { + stmtBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000040); + return this; + } + /** + * 
+       ** Mysqlx.Crud.Find message from which the SELECT statement
+       *is going to be build 
+       *
+ * + * optional .Mysqlx.Crud.Find stmt = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Find.Builder getStmtBuilder() { + bitField0_ |= 0x00000040; + onChanged(); + return getStmtFieldBuilder().getBuilder(); + } + /** + * 
+       ** Mysqlx.Crud.Find message from which the SELECT statement
+       *is going to be build 
+       *
+ * + * optional .Mysqlx.Crud.Find stmt = 7; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.FindOrBuilder getStmtOrBuilder() { + if (stmtBuilder_ != null) { + return stmtBuilder_.getMessageOrBuilder(); + } else { + return stmt_ == null ? + com.mysql.cj.x.protobuf.MysqlxCrud.Find.getDefaultInstance() : stmt_; + } + } + /** + * 
+       ** Mysqlx.Crud.Find message from which the SELECT statement
+       *is going to be build 
+       *
+ * + * optional .Mysqlx.Crud.Find stmt = 7; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Find, com.mysql.cj.x.protobuf.MysqlxCrud.Find.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.FindOrBuilder> + getStmtFieldBuilder() { + if (stmtBuilder_ == null) { + stmtBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Find, com.mysql.cj.x.protobuf.MysqlxCrud.Find.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.FindOrBuilder>( + getStmt(), + getParentForChildren(), + isClean()); + stmt_ = null; + } + return stmtBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Crud.ModifyView) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Crud.ModifyView) + private static final com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView(); + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public ModifyView parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new ModifyView(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.ModifyView getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface DropViewOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Crud.DropView) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** name of the VIEW object, which should be deleted 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return Whether the collection field is set. + */ + boolean hasCollection(); + /** + * 
+     ** name of the VIEW object, which should be deleted 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return The collection. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Collection getCollection(); + /** + * 
+     ** name of the VIEW object, which should be deleted 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder getCollectionOrBuilder(); + + /** + * 
+     ** if true then suppress error when deleted view does not exists 
+     *
+ * + * optional bool if_exists = 2 [default = false]; + * @return Whether the ifExists field is set. + */ + boolean hasIfExists(); + /** + * 
+     ** if true then suppress error when deleted view does not exists 
+     *
+ * + * optional bool if_exists = 2 [default = false]; + * @return The ifExists. + */ + boolean getIfExists(); + } + /** + * 
+   **
+   *DropView removing existing view
+   *
+ * + * Protobuf type {@code Mysqlx.Crud.DropView} + */ + public static final class DropView extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Crud.DropView) + DropViewOrBuilder { + private static final long serialVersionUID = 0L; + // Use DropView.newBuilder() to construct. + private DropView(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private DropView() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new DropView(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private DropView( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) != 0)) { + subBuilder = collection_.toBuilder(); + } + collection_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Collection.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(collection_); + collection_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 16: { + bitField0_ |= 0x00000002; + ifExists_ = input.readBool(); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_DropView_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_DropView_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.DropView.class, com.mysql.cj.x.protobuf.MysqlxCrud.DropView.Builder.class); + } + + private int bitField0_; + public static final int COLLECTION_FIELD_NUMBER = 1; + private com.mysql.cj.x.protobuf.MysqlxCrud.Collection collection_; + /** + * 
+     ** name of the VIEW object, which should be deleted 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return Whether the collection field is set. + */ + public boolean hasCollection() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** name of the VIEW object, which should be deleted 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return The collection. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection getCollection() { + return collection_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } + /** + * 
+     ** name of the VIEW object, which should be deleted 
+     *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder getCollectionOrBuilder() { + return collection_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } + + public static final int IF_EXISTS_FIELD_NUMBER = 2; + private boolean ifExists_; + /** + * 
+     ** if true then suppress error when deleted view does not exists 
+     *
+ * + * optional bool if_exists = 2 [default = false]; + * @return Whether the ifExists field is set. + */ + public boolean hasIfExists() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** if true then suppress error when deleted view does not exists 
+     *
+ * + * optional bool if_exists = 2 [default = false]; + * @return The ifExists. + */ + public boolean getIfExists() { + return ifExists_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasCollection()) { + memoizedIsInitialized = 0; + return false; + } + if (!getCollection().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeMessage(1, getCollection()); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeBool(2, ifExists_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, getCollection()); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(2, ifExists_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxCrud.DropView)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxCrud.DropView other = (com.mysql.cj.x.protobuf.MysqlxCrud.DropView) obj; + + if (hasCollection() != other.hasCollection()) return false; + if (hasCollection()) { + if (!getCollection() + .equals(other.getCollection())) return false; + } + if (hasIfExists() != other.hasIfExists()) return false; + if (hasIfExists()) { + if (getIfExists() + != other.getIfExists()) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasCollection()) { + hash = (37 * hash) + COLLECTION_FIELD_NUMBER; + hash = (53 * hash) + getCollection().hashCode(); + } + if (hasIfExists()) { + hash = (37 * hash) + IF_EXISTS_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getIfExists()); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.DropView parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.DropView parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.DropView parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.DropView parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.DropView parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.DropView parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.DropView parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.DropView parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.DropView parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.DropView parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.DropView parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCrud.DropView parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxCrud.DropView prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *DropView removing existing view
+     *
+ * + * Protobuf type {@code Mysqlx.Crud.DropView} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Crud.DropView) + com.mysql.cj.x.protobuf.MysqlxCrud.DropViewOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_DropView_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_DropView_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCrud.DropView.class, com.mysql.cj.x.protobuf.MysqlxCrud.DropView.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxCrud.DropView.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getCollectionFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + if (collectionBuilder_ == null) { + collection_ = null; + } else { + collectionBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + ifExists_ = false; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.internal_static_Mysqlx_Crud_DropView_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.DropView getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxCrud.DropView.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.DropView build() { + com.mysql.cj.x.protobuf.MysqlxCrud.DropView result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.DropView buildPartial() { + com.mysql.cj.x.protobuf.MysqlxCrud.DropView result = new com.mysql.cj.x.protobuf.MysqlxCrud.DropView(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + if (collectionBuilder_ == null) { + result.collection_ = collection_; + } else { + result.collection_ = collectionBuilder_.build(); + } + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.ifExists_ = ifExists_; + to_bitField0_ |= 0x00000002; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxCrud.DropView) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxCrud.DropView)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxCrud.DropView other) { + if (other == com.mysql.cj.x.protobuf.MysqlxCrud.DropView.getDefaultInstance()) return this; + if (other.hasCollection()) { + mergeCollection(other.getCollection()); + } + if (other.hasIfExists()) { + setIfExists(other.getIfExists()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasCollection()) { + return false; + } + if (!getCollection().isInitialized()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxCrud.DropView parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxCrud.DropView) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private com.mysql.cj.x.protobuf.MysqlxCrud.Collection collection_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Collection, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder> collectionBuilder_; + /** + * 
+       ** name of the VIEW object, which should be deleted 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return Whether the collection field is set. + */ + public boolean hasCollection() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** name of the VIEW object, which should be deleted 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + * @return The collection. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection getCollection() { + if (collectionBuilder_ == null) { + return collection_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } else { + return collectionBuilder_.getMessage(); + } + } + /** + * 
+       ** name of the VIEW object, which should be deleted 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public Builder setCollection(com.mysql.cj.x.protobuf.MysqlxCrud.Collection value) { + if (collectionBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + collection_ = value; + onChanged(); + } else { + collectionBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** name of the VIEW object, which should be deleted 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public Builder setCollection( + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder builderForValue) { + if (collectionBuilder_ == null) { + collection_ = builderForValue.build(); + onChanged(); + } else { + collectionBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** name of the VIEW object, which should be deleted 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public Builder mergeCollection(com.mysql.cj.x.protobuf.MysqlxCrud.Collection value) { + if (collectionBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0) && + collection_ != null && + collection_ != com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance()) { + collection_ = + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.newBuilder(collection_).mergeFrom(value).buildPartial(); + } else { + collection_ = value; + } + onChanged(); + } else { + collectionBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** name of the VIEW object, which should be deleted 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public Builder clearCollection() { + if (collectionBuilder_ == null) { + collection_ = null; + onChanged(); + } else { + collectionBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + /** + * 
+       ** name of the VIEW object, which should be deleted 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder getCollectionBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getCollectionFieldBuilder().getBuilder(); + } + /** + * 
+       ** name of the VIEW object, which should be deleted 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder getCollectionOrBuilder() { + if (collectionBuilder_ != null) { + return collectionBuilder_.getMessageOrBuilder(); + } else { + return collection_ == null ? + com.mysql.cj.x.protobuf.MysqlxCrud.Collection.getDefaultInstance() : collection_; + } + } + /** + * 
+       ** name of the VIEW object, which should be deleted 
+       *
+ * + * required .Mysqlx.Crud.Collection collection = 1; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Collection, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder> + getCollectionFieldBuilder() { + if (collectionBuilder_ == null) { + collectionBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Collection, com.mysql.cj.x.protobuf.MysqlxCrud.Collection.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.CollectionOrBuilder>( + getCollection(), + getParentForChildren(), + isClean()); + collection_ = null; + } + return collectionBuilder_; + } + + private boolean ifExists_ ; + /** + * 
+       ** if true then suppress error when deleted view does not exists 
+       *
+ * + * optional bool if_exists = 2 [default = false]; + * @return Whether the ifExists field is set. + */ + public boolean hasIfExists() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** if true then suppress error when deleted view does not exists 
+       *
+ * + * optional bool if_exists = 2 [default = false]; + * @return The ifExists. + */ + public boolean getIfExists() { + return ifExists_; + } + /** + * 
+       ** if true then suppress error when deleted view does not exists 
+       *
+ * + * optional bool if_exists = 2 [default = false]; + * @param value The ifExists to set. + * @return This builder for chaining. + */ + public Builder setIfExists(boolean value) { + bitField0_ |= 0x00000002; + ifExists_ = value; + onChanged(); + return this; + } + /** + * 
+       ** if true then suppress error when deleted view does not exists 
+       *
+ * + * optional bool if_exists = 2 [default = false]; + * @return This builder for chaining. + */ + public Builder clearIfExists() { + bitField0_ = (bitField0_ & ~0x00000002); + ifExists_ = false; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Crud.DropView) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Crud.DropView) + private static final com.mysql.cj.x.protobuf.MysqlxCrud.DropView DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxCrud.DropView(); + } + + public static com.mysql.cj.x.protobuf.MysqlxCrud.DropView getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public DropView parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new DropView(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCrud.DropView getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Crud_Column_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Crud_Column_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Crud_Projection_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Crud_Projection_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Crud_Collection_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Crud_Collection_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Crud_Limit_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Crud_Limit_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Crud_LimitExpr_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Crud_LimitExpr_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Crud_Order_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Crud_Order_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Crud_UpdateOperation_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Crud_UpdateOperation_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Crud_Find_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Crud_Find_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Crud_Insert_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Crud_Insert_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Crud_Insert_TypedRow_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Crud_Insert_TypedRow_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Crud_Update_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Crud_Update_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Crud_Delete_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Crud_Delete_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Crud_CreateView_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Crud_CreateView_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Crud_ModifyView_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Crud_ModifyView_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Crud_DropView_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Crud_DropView_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\021mysqlx_crud.proto\022\013Mysqlx.Crud\032\014mysqlx" + + ".proto\032\021mysqlx_expr.proto\032\026mysqlx_dataty" + + "pes.proto\"[\n\006Column\022\014\n\004name\030\001 \001(\t\022\r\n\005ali" + + "as\030\002 \001(\t\0224\n\rdocument_path\030\003 \003(\0132\035.Mysqlx" + + ".Expr.DocumentPathItem\">\n\nProjection\022!\n\006" + + "source\030\001 \002(\0132\021.Mysqlx.Expr.Expr\022\r\n\005alias" + + "\030\002 \001(\t\"*\n\nCollection\022\014\n\004name\030\001 \002(\t\022\016\n\006sc" + + "hema\030\002 \001(\t\"*\n\005Limit\022\021\n\trow_count\030\001 \002(\004\022\016" + + "\n\006offset\030\002 \001(\004\"T\n\tLimitExpr\022$\n\trow_count" + + "\030\001 \002(\0132\021.Mysqlx.Expr.Expr\022!\n\006offset\030\002 \001(" + + "\0132\021.Mysqlx.Expr.Expr\"~\n\005Order\022\037\n\004expr\030\001 " + + "\002(\0132\021.Mysqlx.Expr.Expr\0224\n\tdirection\030\002 \001(" + + "\0162\034.Mysqlx.Crud.Order.Direction:\003ASC\"\036\n\t" + + "Direction\022\007\n\003ASC\020\001\022\010\n\004DESC\020\002\"\254\002\n\017UpdateO" + + "peration\022-\n\006source\030\001 \002(\0132\035.Mysqlx.Expr.C" + + "olumnIdentifier\022:\n\toperation\030\002 \002(\0162\'.Mys" + + "qlx.Crud.UpdateOperation.UpdateType\022 \n\005v" + + "alue\030\003 \001(\0132\021.Mysqlx.Expr.Expr\"\213\001\n\nUpdate" + + "Type\022\007\n\003SET\020\001\022\017\n\013ITEM_REMOVE\020\002\022\014\n\010ITEM_S" + + "ET\020\003\022\020\n\014ITEM_REPLACE\020\004\022\016\n\nITEM_MERGE\020\005\022\020" + + "\n\014ARRAY_INSERT\020\006\022\020\n\014ARRAY_APPEND\020\007\022\017\n\013ME" + + "RGE_PATCH\020\010\"\352\004\n\004Find\022+\n\ncollection\030\002 \002(\013" + + "2\027.Mysqlx.Crud.Collection\022*\n\ndata_model\030" + + "\003 \001(\0162\026.Mysqlx.Crud.DataModel\022+\n\nproject" + + "ion\030\004 \003(\0132\027.Mysqlx.Crud.Projection\022&\n\004ar" + + "gs\030\013 \003(\0132\030.Mysqlx.Datatypes.Scalar\022#\n\010cr" + + "iteria\030\005 \001(\0132\021.Mysqlx.Expr.Expr\022!\n\005limit" + + "\030\006 \001(\0132\022.Mysqlx.Crud.Limit\022!\n\005order\030\007 \003(" + + "\0132\022.Mysqlx.Crud.Order\022#\n\010grouping\030\010 \003(\0132" + + "\021.Mysqlx.Expr.Expr\022,\n\021grouping_criteria\030" + + "\t \001(\0132\021.Mysqlx.Expr.Expr\022*\n\007locking\030\014 \001(" + + "\0162\031.Mysqlx.Crud.Find.RowLock\0229\n\017locking_" + + "options\030\r \001(\0162 .Mysqlx.Crud.Find.RowLock" + + "Options\022*\n\nlimit_expr\030\016 \001(\0132\026.Mysqlx.Cru" + + "d.LimitExpr\".\n\007RowLock\022\017\n\013SHARED_LOCK\020\001\022" + + "\022\n\016EXCLUSIVE_LOCK\020\002\"-\n\016RowLockOptions\022\n\n" + + "\006NOWAIT\020\001\022\017\n\013SKIP_LOCKED\020\002:\004\210\3520\021\"\250\002\n\006Ins" + + "ert\022+\n\ncollection\030\001 \002(\0132\027.Mysqlx.Crud.Co" + + "llection\022*\n\ndata_model\030\002 \001(\0162\026.Mysqlx.Cr" + + "ud.DataModel\022\'\n\nprojection\030\003 \003(\0132\023.Mysql" + + "x.Crud.Column\022)\n\003row\030\004 \003(\0132\034.Mysqlx.Crud" + + ".Insert.TypedRow\022&\n\004args\030\005 \003(\0132\030.Mysqlx." + + "Datatypes.Scalar\022\025\n\006upsert\030\006 \001(\010:\005false\032" + + ",\n\010TypedRow\022 \n\005field\030\001 \003(\0132\021.Mysqlx.Expr" + + ".Expr:\004\210\3520\022\"\327\002\n\006Update\022+\n\ncollection\030\002 \002" + + "(\0132\027.Mysqlx.Crud.Collection\022*\n\ndata_mode" + + "l\030\003 \001(\0162\026.Mysqlx.Crud.DataModel\022#\n\010crite" + + "ria\030\004 \001(\0132\021.Mysqlx.Expr.Expr\022!\n\005limit\030\005 " + + "\001(\0132\022.Mysqlx.Crud.Limit\022!\n\005order\030\006 \003(\0132\022" + + ".Mysqlx.Crud.Order\022/\n\toperation\030\007 \003(\0132\034." + + "Mysqlx.Crud.UpdateOperation\022&\n\004args\030\010 \003(" + + "\0132\030.Mysqlx.Datatypes.Scalar\022*\n\nlimit_exp" + + "r\030\t \001(\0132\026.Mysqlx.Crud.LimitExpr:\004\210\3520\023\"\246\002" + + "\n\006Delete\022+\n\ncollection\030\001 \002(\0132\027.Mysqlx.Cr" + + "ud.Collection\022*\n\ndata_model\030\002 \001(\0162\026.Mysq" + + "lx.Crud.DataModel\022#\n\010criteria\030\003 \001(\0132\021.My" + + "sqlx.Expr.Expr\022!\n\005limit\030\004 \001(\0132\022.Mysqlx.C" + + "rud.Limit\022!\n\005order\030\005 \003(\0132\022.Mysqlx.Crud.O" + + "rder\022&\n\004args\030\006 \003(\0132\030.Mysqlx.Datatypes.Sc" + + "alar\022*\n\nlimit_expr\030\007 \001(\0132\026.Mysqlx.Crud.L" + + "imitExpr:\004\210\3520\024\"\302\002\n\nCreateView\022+\n\ncollect" + + "ion\030\001 \002(\0132\027.Mysqlx.Crud.Collection\022\017\n\007de" + + "finer\030\002 \001(\t\0228\n\talgorithm\030\003 \001(\0162\032.Mysqlx." + + "Crud.ViewAlgorithm:\tUNDEFINED\0227\n\010securit" + + "y\030\004 \001(\0162\034.Mysqlx.Crud.ViewSqlSecurity:\007D" + + "EFINER\022+\n\005check\030\005 \001(\0162\034.Mysqlx.Crud.View" + + "CheckOption\022\016\n\006column\030\006 \003(\t\022\037\n\004stmt\030\007 \002(" + + "\0132\021.Mysqlx.Crud.Find\022\037\n\020replace_existing" + + "\030\010 \001(\010:\005false:\004\210\3520\036\"\215\002\n\nModifyView\022+\n\nco" + + "llection\030\001 \002(\0132\027.Mysqlx.Crud.Collection\022" + + "\017\n\007definer\030\002 \001(\t\022-\n\talgorithm\030\003 \001(\0162\032.My" + + "sqlx.Crud.ViewAlgorithm\022.\n\010security\030\004 \001(" + + "\0162\034.Mysqlx.Crud.ViewSqlSecurity\022+\n\005check" + + "\030\005 \001(\0162\034.Mysqlx.Crud.ViewCheckOption\022\016\n\006" + + "column\030\006 \003(\t\022\037\n\004stmt\030\007 \001(\0132\021.Mysqlx.Crud" + + ".Find:\004\210\3520\037\"W\n\010DropView\022+\n\ncollection\030\001 " + + "\002(\0132\027.Mysqlx.Crud.Collection\022\030\n\tif_exist" + + "s\030\002 \001(\010:\005false:\004\210\3520 *$\n\tDataModel\022\014\n\010DOC" + + "UMENT\020\001\022\t\n\005TABLE\020\002*8\n\rViewAlgorithm\022\r\n\tU" + + "NDEFINED\020\001\022\t\n\005MERGE\020\002\022\r\n\tTEMPTABLE\020\003*+\n\017" + + "ViewSqlSecurity\022\013\n\007INVOKER\020\001\022\013\n\007DEFINER\020" + + "\002**\n\017ViewCheckOption\022\t\n\005LOCAL\020\001\022\014\n\010CASCA" + + "DED\020\002B\031\n\027com.mysql.cj.x.protobuf" + }; + descriptor = com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + com.mysql.cj.x.protobuf.Mysqlx.getDescriptor(), + com.mysql.cj.x.protobuf.MysqlxExpr.getDescriptor(), + com.mysql.cj.x.protobuf.MysqlxDatatypes.getDescriptor(), + }); + internal_static_Mysqlx_Crud_Column_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_Mysqlx_Crud_Column_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Crud_Column_descriptor, + new java.lang.String[] { "Name", "Alias", "DocumentPath", }); + internal_static_Mysqlx_Crud_Projection_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_Mysqlx_Crud_Projection_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Crud_Projection_descriptor, + new java.lang.String[] { "Source", "Alias", }); + internal_static_Mysqlx_Crud_Collection_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_Mysqlx_Crud_Collection_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Crud_Collection_descriptor, + new java.lang.String[] { "Name", "Schema", }); + internal_static_Mysqlx_Crud_Limit_descriptor = + getDescriptor().getMessageTypes().get(3); + internal_static_Mysqlx_Crud_Limit_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Crud_Limit_descriptor, + new java.lang.String[] { "RowCount", "Offset", }); + internal_static_Mysqlx_Crud_LimitExpr_descriptor = + getDescriptor().getMessageTypes().get(4); + internal_static_Mysqlx_Crud_LimitExpr_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Crud_LimitExpr_descriptor, + new java.lang.String[] { "RowCount", "Offset", }); + internal_static_Mysqlx_Crud_Order_descriptor = + getDescriptor().getMessageTypes().get(5); + internal_static_Mysqlx_Crud_Order_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Crud_Order_descriptor, + new java.lang.String[] { "Expr", "Direction", }); + internal_static_Mysqlx_Crud_UpdateOperation_descriptor = + getDescriptor().getMessageTypes().get(6); + internal_static_Mysqlx_Crud_UpdateOperation_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Crud_UpdateOperation_descriptor, + new java.lang.String[] { "Source", "Operation", "Value", }); + internal_static_Mysqlx_Crud_Find_descriptor = + getDescriptor().getMessageTypes().get(7); + internal_static_Mysqlx_Crud_Find_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Crud_Find_descriptor, + new java.lang.String[] { "Collection", "DataModel", "Projection", "Args", "Criteria", "Limit", "Order", "Grouping", "GroupingCriteria", "Locking", "LockingOptions", "LimitExpr", }); + internal_static_Mysqlx_Crud_Insert_descriptor = + getDescriptor().getMessageTypes().get(8); + internal_static_Mysqlx_Crud_Insert_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Crud_Insert_descriptor, + new java.lang.String[] { "Collection", "DataModel", "Projection", "Row", "Args", "Upsert", }); + internal_static_Mysqlx_Crud_Insert_TypedRow_descriptor = + internal_static_Mysqlx_Crud_Insert_descriptor.getNestedTypes().get(0); + internal_static_Mysqlx_Crud_Insert_TypedRow_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Crud_Insert_TypedRow_descriptor, + new java.lang.String[] { "Field", }); + internal_static_Mysqlx_Crud_Update_descriptor = + getDescriptor().getMessageTypes().get(9); + internal_static_Mysqlx_Crud_Update_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Crud_Update_descriptor, + new java.lang.String[] { "Collection", "DataModel", "Criteria", "Limit", "Order", "Operation", "Args", "LimitExpr", }); + internal_static_Mysqlx_Crud_Delete_descriptor = + getDescriptor().getMessageTypes().get(10); + internal_static_Mysqlx_Crud_Delete_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Crud_Delete_descriptor, + new java.lang.String[] { "Collection", "DataModel", "Criteria", "Limit", "Order", "Args", "LimitExpr", }); + internal_static_Mysqlx_Crud_CreateView_descriptor = + getDescriptor().getMessageTypes().get(11); + internal_static_Mysqlx_Crud_CreateView_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Crud_CreateView_descriptor, + new java.lang.String[] { "Collection", "Definer", "Algorithm", "Security", "Check", "Column", "Stmt", "ReplaceExisting", }); + internal_static_Mysqlx_Crud_ModifyView_descriptor = + getDescriptor().getMessageTypes().get(12); + internal_static_Mysqlx_Crud_ModifyView_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Crud_ModifyView_descriptor, + new java.lang.String[] { "Collection", "Definer", "Algorithm", "Security", "Check", "Column", "Stmt", }); + internal_static_Mysqlx_Crud_DropView_descriptor = + getDescriptor().getMessageTypes().get(13); + internal_static_Mysqlx_Crud_DropView_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Crud_DropView_descriptor, + new java.lang.String[] { "Collection", "IfExists", }); + com.google.protobuf.ExtensionRegistry registry = + com.google.protobuf.ExtensionRegistry.newInstance(); + registry.add(com.mysql.cj.x.protobuf.Mysqlx.clientMessageId); + com.google.protobuf.Descriptors.FileDescriptor + .internalUpdateFileDescriptor(descriptor, registry); + com.mysql.cj.x.protobuf.Mysqlx.getDescriptor(); + com.mysql.cj.x.protobuf.MysqlxExpr.getDescriptor(); + com.mysql.cj.x.protobuf.MysqlxDatatypes.getDescriptor(); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxCursor.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxCursor.java new file mode 100644 index 0000000..ae47031 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxCursor.java @@ -0,0 +1,3274 @@ +/* + * Copyright (c) 2019, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.x.protobuf; + +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: mysqlx_cursor.proto + +@SuppressWarnings({ "deprecation" }) +public final class MysqlxCursor { + private MysqlxCursor() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + public interface OpenOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Cursor.Open) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** client side assigned cursor id, the ID is going to represent
+     *new cursor and assigned to it statement 
+     *
+ * + * required uint32 cursor_id = 1; + * @return Whether the cursorId field is set. + */ + boolean hasCursorId(); + /** + * 
+     ** client side assigned cursor id, the ID is going to represent
+     *new cursor and assigned to it statement 
+     *
+ * + * required uint32 cursor_id = 1; + * @return The cursorId. + */ + int getCursorId(); + + /** + * 
+     ** statement which resultset is going to be iterated through the cursor 
+     *
+ * + * required .Mysqlx.Cursor.Open.OneOfMessage stmt = 4; + * @return Whether the stmt field is set. + */ + boolean hasStmt(); + /** + * 
+     ** statement which resultset is going to be iterated through the cursor 
+     *
+ * + * required .Mysqlx.Cursor.Open.OneOfMessage stmt = 4; + * @return The stmt. + */ + com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage getStmt(); + /** + * 
+     ** statement which resultset is going to be iterated through the cursor 
+     *
+ * + * required .Mysqlx.Cursor.Open.OneOfMessage stmt = 4; + */ + com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessageOrBuilder getStmtOrBuilder(); + + /** + * 
+     ** number of rows which should be retrieved from sequential cursor 
+     *
+ * + * optional uint64 fetch_rows = 5; + * @return Whether the fetchRows field is set. + */ + boolean hasFetchRows(); + /** + * 
+     ** number of rows which should be retrieved from sequential cursor 
+     *
+ * + * optional uint64 fetch_rows = 5; + * @return The fetchRows. + */ + long getFetchRows(); + } + /** + * 
+   **
+   *Open a cursor
+   *@startuml
+   *client -> server: Open
+   *alt Success
+   *... none or partial Resultsets or full Resultsets ...
+   *client <- server: StmtExecuteOk
+   *else Failure
+   *client <- server: Error
+   *end alt
+   *@enduml
+   *@returns @ref Mysqlx::Ok
+   *
+ * + * Protobuf type {@code Mysqlx.Cursor.Open} + */ + public static final class Open extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Cursor.Open) + OpenOrBuilder { + private static final long serialVersionUID = 0L; + // Use Open.newBuilder() to construct. + private Open(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Open() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Open(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Open( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + bitField0_ |= 0x00000001; + cursorId_ = input.readUInt32(); + break; + } + case 34: { + com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) != 0)) { + subBuilder = stmt_.toBuilder(); + } + stmt_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(stmt_); + stmt_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 40: { + bitField0_ |= 0x00000004; + fetchRows_ = input.readUInt64(); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCursor.internal_static_Mysqlx_Cursor_Open_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCursor.internal_static_Mysqlx_Cursor_Open_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCursor.Open.class, com.mysql.cj.x.protobuf.MysqlxCursor.Open.Builder.class); + } + + public interface OneOfMessageOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Cursor.Open.OneOfMessage) + com.google.protobuf.MessageOrBuilder { + + /** + * required .Mysqlx.Cursor.Open.OneOfMessage.Type type = 1; + * @return Whether the type field is set. + */ + boolean hasType(); + /** + * required .Mysqlx.Cursor.Open.OneOfMessage.Type type = 1; + * @return The type. + */ + com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.Type getType(); + + /** + * optional .Mysqlx.Prepare.Execute prepare_execute = 2; + * @return Whether the prepareExecute field is set. + */ + boolean hasPrepareExecute(); + /** + * optional .Mysqlx.Prepare.Execute prepare_execute = 2; + * @return The prepareExecute. + */ + com.mysql.cj.x.protobuf.MysqlxPrepare.Execute getPrepareExecute(); + /** + * optional .Mysqlx.Prepare.Execute prepare_execute = 2; + */ + com.mysql.cj.x.protobuf.MysqlxPrepare.ExecuteOrBuilder getPrepareExecuteOrBuilder(); + } + /** + * Protobuf type {@code Mysqlx.Cursor.Open.OneOfMessage} + */ + public static final class OneOfMessage extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Cursor.Open.OneOfMessage) + OneOfMessageOrBuilder { + private static final long serialVersionUID = 0L; + // Use OneOfMessage.newBuilder() to construct. + private OneOfMessage(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private OneOfMessage() { + type_ = 0; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new OneOfMessage(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private OneOfMessage( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.Type value = com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.Type.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(1, rawValue); + } else { + bitField0_ |= 0x00000001; + type_ = rawValue; + } + break; + } + case 18: { + com.mysql.cj.x.protobuf.MysqlxPrepare.Execute.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) != 0)) { + subBuilder = prepareExecute_.toBuilder(); + } + prepareExecute_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxPrepare.Execute.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(prepareExecute_); + prepareExecute_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCursor.internal_static_Mysqlx_Cursor_Open_OneOfMessage_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCursor.internal_static_Mysqlx_Cursor_Open_OneOfMessage_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.class, com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.Builder.class); + } + + /** + * Protobuf enum {@code Mysqlx.Cursor.Open.OneOfMessage.Type} + */ + public enum Type + implements com.google.protobuf.ProtocolMessageEnum { + /** + * PREPARE_EXECUTE = 0; + */ + PREPARE_EXECUTE(0), + ; + + /** + * PREPARE_EXECUTE = 0; + */ + public static final int PREPARE_EXECUTE_VALUE = 0; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static Type valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static Type forNumber(int value) { + switch (value) { + case 0: return PREPARE_EXECUTE; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + Type> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Type findValueByNumber(int number) { + return Type.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.getDescriptor().getEnumTypes().get(0); + } + + private static final Type[] VALUES = values(); + + public static Type valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private Type(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Cursor.Open.OneOfMessage.Type) + } + + private int bitField0_; + public static final int TYPE_FIELD_NUMBER = 1; + private int type_; + /** + * required .Mysqlx.Cursor.Open.OneOfMessage.Type type = 1; + * @return Whether the type field is set. + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required .Mysqlx.Cursor.Open.OneOfMessage.Type type = 1; + * @return The type. + */ + public com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.Type getType() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.Type result = com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.Type.valueOf(type_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.Type.PREPARE_EXECUTE : result; + } + + public static final int PREPARE_EXECUTE_FIELD_NUMBER = 2; + private com.mysql.cj.x.protobuf.MysqlxPrepare.Execute prepareExecute_; + /** + * optional .Mysqlx.Prepare.Execute prepare_execute = 2; + * @return Whether the prepareExecute field is set. + */ + public boolean hasPrepareExecute() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional .Mysqlx.Prepare.Execute prepare_execute = 2; + * @return The prepareExecute. + */ + public com.mysql.cj.x.protobuf.MysqlxPrepare.Execute getPrepareExecute() { + return prepareExecute_ == null ? com.mysql.cj.x.protobuf.MysqlxPrepare.Execute.getDefaultInstance() : prepareExecute_; + } + /** + * optional .Mysqlx.Prepare.Execute prepare_execute = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxPrepare.ExecuteOrBuilder getPrepareExecuteOrBuilder() { + return prepareExecute_ == null ? com.mysql.cj.x.protobuf.MysqlxPrepare.Execute.getDefaultInstance() : prepareExecute_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasType()) { + memoizedIsInitialized = 0; + return false; + } + if (hasPrepareExecute()) { + if (!getPrepareExecute().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeEnum(1, type_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeMessage(2, getPrepareExecute()); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(1, type_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, getPrepareExecute()); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage other = (com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage) obj; + + if (hasType() != other.hasType()) return false; + if (hasType()) { + if (type_ != other.type_) return false; + } + if (hasPrepareExecute() != other.hasPrepareExecute()) return false; + if (hasPrepareExecute()) { + if (!getPrepareExecute() + .equals(other.getPrepareExecute())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasType()) { + hash = (37 * hash) + TYPE_FIELD_NUMBER; + hash = (53 * hash) + type_; + } + if (hasPrepareExecute()) { + hash = (37 * hash) + PREPARE_EXECUTE_FIELD_NUMBER; + hash = (53 * hash) + getPrepareExecute().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Mysqlx.Cursor.Open.OneOfMessage} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Cursor.Open.OneOfMessage) + com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessageOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCursor.internal_static_Mysqlx_Cursor_Open_OneOfMessage_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCursor.internal_static_Mysqlx_Cursor_Open_OneOfMessage_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.class, com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getPrepareExecuteFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + type_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + if (prepareExecuteBuilder_ == null) { + prepareExecute_ = null; + } else { + prepareExecuteBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxCursor.internal_static_Mysqlx_Cursor_Open_OneOfMessage_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage build() { + com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage buildPartial() { + com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage result = new com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.type_ = type_; + if (((from_bitField0_ & 0x00000002) != 0)) { + if (prepareExecuteBuilder_ == null) { + result.prepareExecute_ = prepareExecute_; + } else { + result.prepareExecute_ = prepareExecuteBuilder_.build(); + } + to_bitField0_ |= 0x00000002; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage other) { + if (other == com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.getDefaultInstance()) return this; + if (other.hasType()) { + setType(other.getType()); + } + if (other.hasPrepareExecute()) { + mergePrepareExecute(other.getPrepareExecute()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasType()) { + return false; + } + if (hasPrepareExecute()) { + if (!getPrepareExecute().isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int type_ = 0; + /** + * required .Mysqlx.Cursor.Open.OneOfMessage.Type type = 1; + * @return Whether the type field is set. + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required .Mysqlx.Cursor.Open.OneOfMessage.Type type = 1; + * @return The type. + */ + public com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.Type getType() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.Type result = com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.Type.valueOf(type_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.Type.PREPARE_EXECUTE : result; + } + /** + * required .Mysqlx.Cursor.Open.OneOfMessage.Type type = 1; + * @param value The type to set. + * @return This builder for chaining. + */ + public Builder setType(com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.Type value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + type_ = value.getNumber(); + onChanged(); + return this; + } + /** + * required .Mysqlx.Cursor.Open.OneOfMessage.Type type = 1; + * @return This builder for chaining. + */ + public Builder clearType() { + bitField0_ = (bitField0_ & ~0x00000001); + type_ = 0; + onChanged(); + return this; + } + + private com.mysql.cj.x.protobuf.MysqlxPrepare.Execute prepareExecute_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxPrepare.Execute, com.mysql.cj.x.protobuf.MysqlxPrepare.Execute.Builder, com.mysql.cj.x.protobuf.MysqlxPrepare.ExecuteOrBuilder> prepareExecuteBuilder_; + /** + * optional .Mysqlx.Prepare.Execute prepare_execute = 2; + * @return Whether the prepareExecute field is set. + */ + public boolean hasPrepareExecute() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional .Mysqlx.Prepare.Execute prepare_execute = 2; + * @return The prepareExecute. + */ + public com.mysql.cj.x.protobuf.MysqlxPrepare.Execute getPrepareExecute() { + if (prepareExecuteBuilder_ == null) { + return prepareExecute_ == null ? com.mysql.cj.x.protobuf.MysqlxPrepare.Execute.getDefaultInstance() : prepareExecute_; + } else { + return prepareExecuteBuilder_.getMessage(); + } + } + /** + * optional .Mysqlx.Prepare.Execute prepare_execute = 2; + */ + public Builder setPrepareExecute(com.mysql.cj.x.protobuf.MysqlxPrepare.Execute value) { + if (prepareExecuteBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + prepareExecute_ = value; + onChanged(); + } else { + prepareExecuteBuilder_.setMessage(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .Mysqlx.Prepare.Execute prepare_execute = 2; + */ + public Builder setPrepareExecute( + com.mysql.cj.x.protobuf.MysqlxPrepare.Execute.Builder builderForValue) { + if (prepareExecuteBuilder_ == null) { + prepareExecute_ = builderForValue.build(); + onChanged(); + } else { + prepareExecuteBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .Mysqlx.Prepare.Execute prepare_execute = 2; + */ + public Builder mergePrepareExecute(com.mysql.cj.x.protobuf.MysqlxPrepare.Execute value) { + if (prepareExecuteBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0) && + prepareExecute_ != null && + prepareExecute_ != com.mysql.cj.x.protobuf.MysqlxPrepare.Execute.getDefaultInstance()) { + prepareExecute_ = + com.mysql.cj.x.protobuf.MysqlxPrepare.Execute.newBuilder(prepareExecute_).mergeFrom(value).buildPartial(); + } else { + prepareExecute_ = value; + } + onChanged(); + } else { + prepareExecuteBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .Mysqlx.Prepare.Execute prepare_execute = 2; + */ + public Builder clearPrepareExecute() { + if (prepareExecuteBuilder_ == null) { + prepareExecute_ = null; + onChanged(); + } else { + prepareExecuteBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + /** + * optional .Mysqlx.Prepare.Execute prepare_execute = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxPrepare.Execute.Builder getPrepareExecuteBuilder() { + bitField0_ |= 0x00000002; + onChanged(); + return getPrepareExecuteFieldBuilder().getBuilder(); + } + /** + * optional .Mysqlx.Prepare.Execute prepare_execute = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxPrepare.ExecuteOrBuilder getPrepareExecuteOrBuilder() { + if (prepareExecuteBuilder_ != null) { + return prepareExecuteBuilder_.getMessageOrBuilder(); + } else { + return prepareExecute_ == null ? + com.mysql.cj.x.protobuf.MysqlxPrepare.Execute.getDefaultInstance() : prepareExecute_; + } + } + /** + * optional .Mysqlx.Prepare.Execute prepare_execute = 2; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxPrepare.Execute, com.mysql.cj.x.protobuf.MysqlxPrepare.Execute.Builder, com.mysql.cj.x.protobuf.MysqlxPrepare.ExecuteOrBuilder> + getPrepareExecuteFieldBuilder() { + if (prepareExecuteBuilder_ == null) { + prepareExecuteBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxPrepare.Execute, com.mysql.cj.x.protobuf.MysqlxPrepare.Execute.Builder, com.mysql.cj.x.protobuf.MysqlxPrepare.ExecuteOrBuilder>( + getPrepareExecute(), + getParentForChildren(), + isClean()); + prepareExecute_ = null; + } + return prepareExecuteBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Cursor.Open.OneOfMessage) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Cursor.Open.OneOfMessage) + private static final com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage(); + } + + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public OneOfMessage parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new OneOfMessage(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private int bitField0_; + public static final int CURSOR_ID_FIELD_NUMBER = 1; + private int cursorId_; + /** + * 
+     ** client side assigned cursor id, the ID is going to represent
+     *new cursor and assigned to it statement 
+     *
+ * + * required uint32 cursor_id = 1; + * @return Whether the cursorId field is set. + */ + public boolean hasCursorId() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** client side assigned cursor id, the ID is going to represent
+     *new cursor and assigned to it statement 
+     *
+ * + * required uint32 cursor_id = 1; + * @return The cursorId. + */ + public int getCursorId() { + return cursorId_; + } + + public static final int STMT_FIELD_NUMBER = 4; + private com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage stmt_; + /** + * 
+     ** statement which resultset is going to be iterated through the cursor 
+     *
+ * + * required .Mysqlx.Cursor.Open.OneOfMessage stmt = 4; + * @return Whether the stmt field is set. + */ + public boolean hasStmt() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** statement which resultset is going to be iterated through the cursor 
+     *
+ * + * required .Mysqlx.Cursor.Open.OneOfMessage stmt = 4; + * @return The stmt. + */ + public com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage getStmt() { + return stmt_ == null ? com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.getDefaultInstance() : stmt_; + } + /** + * 
+     ** statement which resultset is going to be iterated through the cursor 
+     *
+ * + * required .Mysqlx.Cursor.Open.OneOfMessage stmt = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessageOrBuilder getStmtOrBuilder() { + return stmt_ == null ? com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.getDefaultInstance() : stmt_; + } + + public static final int FETCH_ROWS_FIELD_NUMBER = 5; + private long fetchRows_; + /** + * 
+     ** number of rows which should be retrieved from sequential cursor 
+     *
+ * + * optional uint64 fetch_rows = 5; + * @return Whether the fetchRows field is set. + */ + public boolean hasFetchRows() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+     ** number of rows which should be retrieved from sequential cursor 
+     *
+ * + * optional uint64 fetch_rows = 5; + * @return The fetchRows. + */ + public long getFetchRows() { + return fetchRows_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasCursorId()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasStmt()) { + memoizedIsInitialized = 0; + return false; + } + if (!getStmt().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeUInt32(1, cursorId_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeMessage(4, getStmt()); + } + if (((bitField0_ & 0x00000004) != 0)) { + output.writeUInt64(5, fetchRows_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(1, cursorId_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, getStmt()); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt64Size(5, fetchRows_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxCursor.Open)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxCursor.Open other = (com.mysql.cj.x.protobuf.MysqlxCursor.Open) obj; + + if (hasCursorId() != other.hasCursorId()) return false; + if (hasCursorId()) { + if (getCursorId() + != other.getCursorId()) return false; + } + if (hasStmt() != other.hasStmt()) return false; + if (hasStmt()) { + if (!getStmt() + .equals(other.getStmt())) return false; + } + if (hasFetchRows() != other.hasFetchRows()) return false; + if (hasFetchRows()) { + if (getFetchRows() + != other.getFetchRows()) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasCursorId()) { + hash = (37 * hash) + CURSOR_ID_FIELD_NUMBER; + hash = (53 * hash) + getCursorId(); + } + if (hasStmt()) { + hash = (37 * hash) + STMT_FIELD_NUMBER; + hash = (53 * hash) + getStmt().hashCode(); + } + if (hasFetchRows()) { + hash = (37 * hash) + FETCH_ROWS_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getFetchRows()); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxCursor.Open prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Open a cursor
+     *@startuml
+     *client -> server: Open
+     *alt Success
+     *... none or partial Resultsets or full Resultsets ...
+     *client <- server: StmtExecuteOk
+     *else Failure
+     *client <- server: Error
+     *end alt
+     *@enduml
+     *@returns @ref Mysqlx::Ok
+     *
+ * + * Protobuf type {@code Mysqlx.Cursor.Open} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Cursor.Open) + com.mysql.cj.x.protobuf.MysqlxCursor.OpenOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCursor.internal_static_Mysqlx_Cursor_Open_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCursor.internal_static_Mysqlx_Cursor_Open_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCursor.Open.class, com.mysql.cj.x.protobuf.MysqlxCursor.Open.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxCursor.Open.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getStmtFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + cursorId_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + if (stmtBuilder_ == null) { + stmt_ = null; + } else { + stmtBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + fetchRows_ = 0L; + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxCursor.internal_static_Mysqlx_Cursor_Open_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCursor.Open getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxCursor.Open.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCursor.Open build() { + com.mysql.cj.x.protobuf.MysqlxCursor.Open result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCursor.Open buildPartial() { + com.mysql.cj.x.protobuf.MysqlxCursor.Open result = new com.mysql.cj.x.protobuf.MysqlxCursor.Open(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.cursorId_ = cursorId_; + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + if (stmtBuilder_ == null) { + result.stmt_ = stmt_; + } else { + result.stmt_ = stmtBuilder_.build(); + } + to_bitField0_ |= 0x00000002; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + result.fetchRows_ = fetchRows_; + to_bitField0_ |= 0x00000004; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxCursor.Open) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxCursor.Open)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxCursor.Open other) { + if (other == com.mysql.cj.x.protobuf.MysqlxCursor.Open.getDefaultInstance()) return this; + if (other.hasCursorId()) { + setCursorId(other.getCursorId()); + } + if (other.hasStmt()) { + mergeStmt(other.getStmt()); + } + if (other.hasFetchRows()) { + setFetchRows(other.getFetchRows()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasCursorId()) { + return false; + } + if (!hasStmt()) { + return false; + } + if (!getStmt().isInitialized()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxCursor.Open parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxCursor.Open) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int cursorId_ ; + /** + * 
+       ** client side assigned cursor id, the ID is going to represent
+       *new cursor and assigned to it statement 
+       *
+ * + * required uint32 cursor_id = 1; + * @return Whether the cursorId field is set. + */ + public boolean hasCursorId() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** client side assigned cursor id, the ID is going to represent
+       *new cursor and assigned to it statement 
+       *
+ * + * required uint32 cursor_id = 1; + * @return The cursorId. + */ + public int getCursorId() { + return cursorId_; + } + /** + * 
+       ** client side assigned cursor id, the ID is going to represent
+       *new cursor and assigned to it statement 
+       *
+ * + * required uint32 cursor_id = 1; + * @param value The cursorId to set. + * @return This builder for chaining. + */ + public Builder setCursorId(int value) { + bitField0_ |= 0x00000001; + cursorId_ = value; + onChanged(); + return this; + } + /** + * 
+       ** client side assigned cursor id, the ID is going to represent
+       *new cursor and assigned to it statement 
+       *
+ * + * required uint32 cursor_id = 1; + * @return This builder for chaining. + */ + public Builder clearCursorId() { + bitField0_ = (bitField0_ & ~0x00000001); + cursorId_ = 0; + onChanged(); + return this; + } + + private com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage stmt_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage, com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.Builder, com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessageOrBuilder> stmtBuilder_; + /** + * 
+       ** statement which resultset is going to be iterated through the cursor 
+       *
+ * + * required .Mysqlx.Cursor.Open.OneOfMessage stmt = 4; + * @return Whether the stmt field is set. + */ + public boolean hasStmt() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** statement which resultset is going to be iterated through the cursor 
+       *
+ * + * required .Mysqlx.Cursor.Open.OneOfMessage stmt = 4; + * @return The stmt. + */ + public com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage getStmt() { + if (stmtBuilder_ == null) { + return stmt_ == null ? com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.getDefaultInstance() : stmt_; + } else { + return stmtBuilder_.getMessage(); + } + } + /** + * 
+       ** statement which resultset is going to be iterated through the cursor 
+       *
+ * + * required .Mysqlx.Cursor.Open.OneOfMessage stmt = 4; + */ + public Builder setStmt(com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage value) { + if (stmtBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + stmt_ = value; + onChanged(); + } else { + stmtBuilder_.setMessage(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * 
+       ** statement which resultset is going to be iterated through the cursor 
+       *
+ * + * required .Mysqlx.Cursor.Open.OneOfMessage stmt = 4; + */ + public Builder setStmt( + com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.Builder builderForValue) { + if (stmtBuilder_ == null) { + stmt_ = builderForValue.build(); + onChanged(); + } else { + stmtBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * 
+       ** statement which resultset is going to be iterated through the cursor 
+       *
+ * + * required .Mysqlx.Cursor.Open.OneOfMessage stmt = 4; + */ + public Builder mergeStmt(com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage value) { + if (stmtBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0) && + stmt_ != null && + stmt_ != com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.getDefaultInstance()) { + stmt_ = + com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.newBuilder(stmt_).mergeFrom(value).buildPartial(); + } else { + stmt_ = value; + } + onChanged(); + } else { + stmtBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * 
+       ** statement which resultset is going to be iterated through the cursor 
+       *
+ * + * required .Mysqlx.Cursor.Open.OneOfMessage stmt = 4; + */ + public Builder clearStmt() { + if (stmtBuilder_ == null) { + stmt_ = null; + onChanged(); + } else { + stmtBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + /** + * 
+       ** statement which resultset is going to be iterated through the cursor 
+       *
+ * + * required .Mysqlx.Cursor.Open.OneOfMessage stmt = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.Builder getStmtBuilder() { + bitField0_ |= 0x00000002; + onChanged(); + return getStmtFieldBuilder().getBuilder(); + } + /** + * 
+       ** statement which resultset is going to be iterated through the cursor 
+       *
+ * + * required .Mysqlx.Cursor.Open.OneOfMessage stmt = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessageOrBuilder getStmtOrBuilder() { + if (stmtBuilder_ != null) { + return stmtBuilder_.getMessageOrBuilder(); + } else { + return stmt_ == null ? + com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.getDefaultInstance() : stmt_; + } + } + /** + * 
+       ** statement which resultset is going to be iterated through the cursor 
+       *
+ * + * required .Mysqlx.Cursor.Open.OneOfMessage stmt = 4; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage, com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.Builder, com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessageOrBuilder> + getStmtFieldBuilder() { + if (stmtBuilder_ == null) { + stmtBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage, com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessage.Builder, com.mysql.cj.x.protobuf.MysqlxCursor.Open.OneOfMessageOrBuilder>( + getStmt(), + getParentForChildren(), + isClean()); + stmt_ = null; + } + return stmtBuilder_; + } + + private long fetchRows_ ; + /** + * 
+       ** number of rows which should be retrieved from sequential cursor 
+       *
+ * + * optional uint64 fetch_rows = 5; + * @return Whether the fetchRows field is set. + */ + public boolean hasFetchRows() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+       ** number of rows which should be retrieved from sequential cursor 
+       *
+ * + * optional uint64 fetch_rows = 5; + * @return The fetchRows. + */ + public long getFetchRows() { + return fetchRows_; + } + /** + * 
+       ** number of rows which should be retrieved from sequential cursor 
+       *
+ * + * optional uint64 fetch_rows = 5; + * @param value The fetchRows to set. + * @return This builder for chaining. + */ + public Builder setFetchRows(long value) { + bitField0_ |= 0x00000004; + fetchRows_ = value; + onChanged(); + return this; + } + /** + * 
+       ** number of rows which should be retrieved from sequential cursor 
+       *
+ * + * optional uint64 fetch_rows = 5; + * @return This builder for chaining. + */ + public Builder clearFetchRows() { + bitField0_ = (bitField0_ & ~0x00000004); + fetchRows_ = 0L; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Cursor.Open) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Cursor.Open) + private static final com.mysql.cj.x.protobuf.MysqlxCursor.Open DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxCursor.Open(); + } + + public static com.mysql.cj.x.protobuf.MysqlxCursor.Open getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Open parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Open(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCursor.Open getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface FetchOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Cursor.Fetch) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** client side assigned cursor id, must be already open 
+     *
+ * + * required uint32 cursor_id = 1; + * @return Whether the cursorId field is set. + */ + boolean hasCursorId(); + /** + * 
+     ** client side assigned cursor id, must be already open 
+     *
+ * + * required uint32 cursor_id = 1; + * @return The cursorId. + */ + int getCursorId(); + + /** + * 
+     ** number of rows which should be retrieved from sequential cursor 
+     *
+ * + * optional uint64 fetch_rows = 5; + * @return Whether the fetchRows field is set. + */ + boolean hasFetchRows(); + /** + * 
+     ** number of rows which should be retrieved from sequential cursor 
+     *
+ * + * optional uint64 fetch_rows = 5; + * @return The fetchRows. + */ + long getFetchRows(); + } + /** + * 
+   **
+   *Fetch next portion of data from a cursor
+   *@startuml
+   *client -> server: Fetch
+   *alt Success
+   *... none or partial Resultsets or full Resultsets ...
+   *client <- server: StmtExecuteOk
+   *else
+   *client <- server: Error
+   *end
+   *@enduml
+   *
+ * + * Protobuf type {@code Mysqlx.Cursor.Fetch} + */ + public static final class Fetch extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Cursor.Fetch) + FetchOrBuilder { + private static final long serialVersionUID = 0L; + // Use Fetch.newBuilder() to construct. + private Fetch(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Fetch() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Fetch(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Fetch( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + bitField0_ |= 0x00000001; + cursorId_ = input.readUInt32(); + break; + } + case 40: { + bitField0_ |= 0x00000002; + fetchRows_ = input.readUInt64(); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCursor.internal_static_Mysqlx_Cursor_Fetch_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCursor.internal_static_Mysqlx_Cursor_Fetch_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCursor.Fetch.class, com.mysql.cj.x.protobuf.MysqlxCursor.Fetch.Builder.class); + } + + private int bitField0_; + public static final int CURSOR_ID_FIELD_NUMBER = 1; + private int cursorId_; + /** + * 
+     ** client side assigned cursor id, must be already open 
+     *
+ * + * required uint32 cursor_id = 1; + * @return Whether the cursorId field is set. + */ + public boolean hasCursorId() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** client side assigned cursor id, must be already open 
+     *
+ * + * required uint32 cursor_id = 1; + * @return The cursorId. + */ + public int getCursorId() { + return cursorId_; + } + + public static final int FETCH_ROWS_FIELD_NUMBER = 5; + private long fetchRows_; + /** + * 
+     ** number of rows which should be retrieved from sequential cursor 
+     *
+ * + * optional uint64 fetch_rows = 5; + * @return Whether the fetchRows field is set. + */ + public boolean hasFetchRows() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** number of rows which should be retrieved from sequential cursor 
+     *
+ * + * optional uint64 fetch_rows = 5; + * @return The fetchRows. + */ + public long getFetchRows() { + return fetchRows_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasCursorId()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeUInt32(1, cursorId_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeUInt64(5, fetchRows_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(1, cursorId_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt64Size(5, fetchRows_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxCursor.Fetch)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxCursor.Fetch other = (com.mysql.cj.x.protobuf.MysqlxCursor.Fetch) obj; + + if (hasCursorId() != other.hasCursorId()) return false; + if (hasCursorId()) { + if (getCursorId() + != other.getCursorId()) return false; + } + if (hasFetchRows() != other.hasFetchRows()) return false; + if (hasFetchRows()) { + if (getFetchRows() + != other.getFetchRows()) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasCursorId()) { + hash = (37 * hash) + CURSOR_ID_FIELD_NUMBER; + hash = (53 * hash) + getCursorId(); + } + if (hasFetchRows()) { + hash = (37 * hash) + FETCH_ROWS_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getFetchRows()); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxCursor.Fetch parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Fetch parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Fetch parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Fetch parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Fetch parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Fetch parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Fetch parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Fetch parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Fetch parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Fetch parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Fetch parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Fetch parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxCursor.Fetch prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Fetch next portion of data from a cursor
+     *@startuml
+     *client -> server: Fetch
+     *alt Success
+     *... none or partial Resultsets or full Resultsets ...
+     *client <- server: StmtExecuteOk
+     *else
+     *client <- server: Error
+     *end
+     *@enduml
+     *
+ * + * Protobuf type {@code Mysqlx.Cursor.Fetch} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Cursor.Fetch) + com.mysql.cj.x.protobuf.MysqlxCursor.FetchOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCursor.internal_static_Mysqlx_Cursor_Fetch_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCursor.internal_static_Mysqlx_Cursor_Fetch_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCursor.Fetch.class, com.mysql.cj.x.protobuf.MysqlxCursor.Fetch.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxCursor.Fetch.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + cursorId_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + fetchRows_ = 0L; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxCursor.internal_static_Mysqlx_Cursor_Fetch_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCursor.Fetch getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxCursor.Fetch.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCursor.Fetch build() { + com.mysql.cj.x.protobuf.MysqlxCursor.Fetch result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCursor.Fetch buildPartial() { + com.mysql.cj.x.protobuf.MysqlxCursor.Fetch result = new com.mysql.cj.x.protobuf.MysqlxCursor.Fetch(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.cursorId_ = cursorId_; + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + result.fetchRows_ = fetchRows_; + to_bitField0_ |= 0x00000002; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxCursor.Fetch) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxCursor.Fetch)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxCursor.Fetch other) { + if (other == com.mysql.cj.x.protobuf.MysqlxCursor.Fetch.getDefaultInstance()) return this; + if (other.hasCursorId()) { + setCursorId(other.getCursorId()); + } + if (other.hasFetchRows()) { + setFetchRows(other.getFetchRows()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasCursorId()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxCursor.Fetch parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxCursor.Fetch) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int cursorId_ ; + /** + * 
+       ** client side assigned cursor id, must be already open 
+       *
+ * + * required uint32 cursor_id = 1; + * @return Whether the cursorId field is set. + */ + public boolean hasCursorId() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** client side assigned cursor id, must be already open 
+       *
+ * + * required uint32 cursor_id = 1; + * @return The cursorId. + */ + public int getCursorId() { + return cursorId_; + } + /** + * 
+       ** client side assigned cursor id, must be already open 
+       *
+ * + * required uint32 cursor_id = 1; + * @param value The cursorId to set. + * @return This builder for chaining. + */ + public Builder setCursorId(int value) { + bitField0_ |= 0x00000001; + cursorId_ = value; + onChanged(); + return this; + } + /** + * 
+       ** client side assigned cursor id, must be already open 
+       *
+ * + * required uint32 cursor_id = 1; + * @return This builder for chaining. + */ + public Builder clearCursorId() { + bitField0_ = (bitField0_ & ~0x00000001); + cursorId_ = 0; + onChanged(); + return this; + } + + private long fetchRows_ ; + /** + * 
+       ** number of rows which should be retrieved from sequential cursor 
+       *
+ * + * optional uint64 fetch_rows = 5; + * @return Whether the fetchRows field is set. + */ + public boolean hasFetchRows() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** number of rows which should be retrieved from sequential cursor 
+       *
+ * + * optional uint64 fetch_rows = 5; + * @return The fetchRows. + */ + public long getFetchRows() { + return fetchRows_; + } + /** + * 
+       ** number of rows which should be retrieved from sequential cursor 
+       *
+ * + * optional uint64 fetch_rows = 5; + * @param value The fetchRows to set. + * @return This builder for chaining. + */ + public Builder setFetchRows(long value) { + bitField0_ |= 0x00000002; + fetchRows_ = value; + onChanged(); + return this; + } + /** + * 
+       ** number of rows which should be retrieved from sequential cursor 
+       *
+ * + * optional uint64 fetch_rows = 5; + * @return This builder for chaining. + */ + public Builder clearFetchRows() { + bitField0_ = (bitField0_ & ~0x00000002); + fetchRows_ = 0L; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Cursor.Fetch) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Cursor.Fetch) + private static final com.mysql.cj.x.protobuf.MysqlxCursor.Fetch DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxCursor.Fetch(); + } + + public static com.mysql.cj.x.protobuf.MysqlxCursor.Fetch getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Fetch parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Fetch(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCursor.Fetch getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface CloseOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Cursor.Close) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** client side assigned cursor id, must be allocated/open 
+     *
+ * + * required uint32 cursor_id = 1; + * @return Whether the cursorId field is set. + */ + boolean hasCursorId(); + /** + * 
+     ** client side assigned cursor id, must be allocated/open 
+     *
+ * + * required uint32 cursor_id = 1; + * @return The cursorId. + */ + int getCursorId(); + } + /** + * 
+   **
+   *Close cursor
+   *@startuml
+   *client -> server: Close
+   *alt Success
+   *client <- server: Ok
+   *else Failure
+   *client <- server: Error
+   *end
+   *@enduml
+   *@returns @ref Mysqlx::Ok or @ref Mysqlx::Error
+   *
+ * + * Protobuf type {@code Mysqlx.Cursor.Close} + */ + public static final class Close extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Cursor.Close) + CloseOrBuilder { + private static final long serialVersionUID = 0L; + // Use Close.newBuilder() to construct. + private Close(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Close() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Close(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Close( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + bitField0_ |= 0x00000001; + cursorId_ = input.readUInt32(); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCursor.internal_static_Mysqlx_Cursor_Close_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCursor.internal_static_Mysqlx_Cursor_Close_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCursor.Close.class, com.mysql.cj.x.protobuf.MysqlxCursor.Close.Builder.class); + } + + private int bitField0_; + public static final int CURSOR_ID_FIELD_NUMBER = 1; + private int cursorId_; + /** + * 
+     ** client side assigned cursor id, must be allocated/open 
+     *
+ * + * required uint32 cursor_id = 1; + * @return Whether the cursorId field is set. + */ + public boolean hasCursorId() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** client side assigned cursor id, must be allocated/open 
+     *
+ * + * required uint32 cursor_id = 1; + * @return The cursorId. + */ + public int getCursorId() { + return cursorId_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasCursorId()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeUInt32(1, cursorId_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(1, cursorId_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxCursor.Close)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxCursor.Close other = (com.mysql.cj.x.protobuf.MysqlxCursor.Close) obj; + + if (hasCursorId() != other.hasCursorId()) return false; + if (hasCursorId()) { + if (getCursorId() + != other.getCursorId()) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasCursorId()) { + hash = (37 * hash) + CURSOR_ID_FIELD_NUMBER; + hash = (53 * hash) + getCursorId(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxCursor.Close parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Close parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Close parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Close parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Close parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Close parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Close parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Close parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Close parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Close parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Close parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxCursor.Close parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxCursor.Close prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Close cursor
+     *@startuml
+     *client -> server: Close
+     *alt Success
+     *client <- server: Ok
+     *else Failure
+     *client <- server: Error
+     *end
+     *@enduml
+     *@returns @ref Mysqlx::Ok or @ref Mysqlx::Error
+     *
+ * + * Protobuf type {@code Mysqlx.Cursor.Close} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Cursor.Close) + com.mysql.cj.x.protobuf.MysqlxCursor.CloseOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxCursor.internal_static_Mysqlx_Cursor_Close_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxCursor.internal_static_Mysqlx_Cursor_Close_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxCursor.Close.class, com.mysql.cj.x.protobuf.MysqlxCursor.Close.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxCursor.Close.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + cursorId_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxCursor.internal_static_Mysqlx_Cursor_Close_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCursor.Close getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxCursor.Close.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCursor.Close build() { + com.mysql.cj.x.protobuf.MysqlxCursor.Close result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCursor.Close buildPartial() { + com.mysql.cj.x.protobuf.MysqlxCursor.Close result = new com.mysql.cj.x.protobuf.MysqlxCursor.Close(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.cursorId_ = cursorId_; + to_bitField0_ |= 0x00000001; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxCursor.Close) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxCursor.Close)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxCursor.Close other) { + if (other == com.mysql.cj.x.protobuf.MysqlxCursor.Close.getDefaultInstance()) return this; + if (other.hasCursorId()) { + setCursorId(other.getCursorId()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasCursorId()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxCursor.Close parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxCursor.Close) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int cursorId_ ; + /** + * 
+       ** client side assigned cursor id, must be allocated/open 
+       *
+ * + * required uint32 cursor_id = 1; + * @return Whether the cursorId field is set. + */ + public boolean hasCursorId() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** client side assigned cursor id, must be allocated/open 
+       *
+ * + * required uint32 cursor_id = 1; + * @return The cursorId. + */ + public int getCursorId() { + return cursorId_; + } + /** + * 
+       ** client side assigned cursor id, must be allocated/open 
+       *
+ * + * required uint32 cursor_id = 1; + * @param value The cursorId to set. + * @return This builder for chaining. + */ + public Builder setCursorId(int value) { + bitField0_ |= 0x00000001; + cursorId_ = value; + onChanged(); + return this; + } + /** + * 
+       ** client side assigned cursor id, must be allocated/open 
+       *
+ * + * required uint32 cursor_id = 1; + * @return This builder for chaining. + */ + public Builder clearCursorId() { + bitField0_ = (bitField0_ & ~0x00000001); + cursorId_ = 0; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Cursor.Close) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Cursor.Close) + private static final com.mysql.cj.x.protobuf.MysqlxCursor.Close DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxCursor.Close(); + } + + public static com.mysql.cj.x.protobuf.MysqlxCursor.Close getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Close parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Close(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxCursor.Close getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Cursor_Open_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Cursor_Open_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Cursor_Open_OneOfMessage_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Cursor_Open_OneOfMessage_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Cursor_Fetch_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Cursor_Fetch_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Cursor_Close_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Cursor_Close_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\023mysqlx_cursor.proto\022\rMysqlx.Cursor\032\014my" + + "sqlx.proto\032\024mysqlx_prepare.proto\"\370\001\n\004Ope" + + "n\022\021\n\tcursor_id\030\001 \002(\r\022.\n\004stmt\030\004 \002(\0132 .Mys" + + "qlx.Cursor.Open.OneOfMessage\022\022\n\nfetch_ro" + + "ws\030\005 \001(\004\032\222\001\n\014OneOfMessage\0223\n\004type\030\001 \002(\0162" + + "%.Mysqlx.Cursor.Open.OneOfMessage.Type\0220" + + "\n\017prepare_execute\030\002 \001(\0132\027.Mysqlx.Prepare" + + ".Execute\"\033\n\004Type\022\023\n\017PREPARE_EXECUTE\020\000:\004\210" + + "\3520+\"4\n\005Fetch\022\021\n\tcursor_id\030\001 \002(\r\022\022\n\nfetch" + + "_rows\030\005 \001(\004:\004\210\3520-\" \n\005Close\022\021\n\tcursor_id\030" + + "\001 \002(\r:\004\210\3520,B\031\n\027com.mysql.cj.x.protobuf" + }; + descriptor = com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + com.mysql.cj.x.protobuf.Mysqlx.getDescriptor(), + com.mysql.cj.x.protobuf.MysqlxPrepare.getDescriptor(), + }); + internal_static_Mysqlx_Cursor_Open_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_Mysqlx_Cursor_Open_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Cursor_Open_descriptor, + new java.lang.String[] { "CursorId", "Stmt", "FetchRows", }); + internal_static_Mysqlx_Cursor_Open_OneOfMessage_descriptor = + internal_static_Mysqlx_Cursor_Open_descriptor.getNestedTypes().get(0); + internal_static_Mysqlx_Cursor_Open_OneOfMessage_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Cursor_Open_OneOfMessage_descriptor, + new java.lang.String[] { "Type", "PrepareExecute", }); + internal_static_Mysqlx_Cursor_Fetch_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_Mysqlx_Cursor_Fetch_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Cursor_Fetch_descriptor, + new java.lang.String[] { "CursorId", "FetchRows", }); + internal_static_Mysqlx_Cursor_Close_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_Mysqlx_Cursor_Close_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Cursor_Close_descriptor, + new java.lang.String[] { "CursorId", }); + com.google.protobuf.ExtensionRegistry registry = + com.google.protobuf.ExtensionRegistry.newInstance(); + registry.add(com.mysql.cj.x.protobuf.Mysqlx.clientMessageId); + com.google.protobuf.Descriptors.FileDescriptor + .internalUpdateFileDescriptor(descriptor, registry); + com.mysql.cj.x.protobuf.Mysqlx.getDescriptor(); + com.mysql.cj.x.protobuf.MysqlxPrepare.getDescriptor(); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxDatatypes.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxDatatypes.java new file mode 100644 index 0000000..7373690 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxDatatypes.java @@ -0,0 +1,6854 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.x.protobuf; + +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: mysqlx_datatypes.proto + +public final class MysqlxDatatypes { + private MysqlxDatatypes() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + public interface ScalarOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Datatypes.Scalar) + com.google.protobuf.MessageOrBuilder { + + /** + * required .Mysqlx.Datatypes.Scalar.Type type = 1; + * @return Whether the type field is set. + */ + boolean hasType(); + /** + * required .Mysqlx.Datatypes.Scalar.Type type = 1; + * @return The type. + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Type getType(); + + /** + * optional sint64 v_signed_int = 2; + * @return Whether the vSignedInt field is set. + */ + boolean hasVSignedInt(); + /** + * optional sint64 v_signed_int = 2; + * @return The vSignedInt. + */ + long getVSignedInt(); + + /** + * optional uint64 v_unsigned_int = 3; + * @return Whether the vUnsignedInt field is set. + */ + boolean hasVUnsignedInt(); + /** + * optional uint64 v_unsigned_int = 3; + * @return The vUnsignedInt. + */ + long getVUnsignedInt(); + + /** + * 
+     * 4 is unused, was Null which doesn't have a storage anymore
+     *
+ * + * optional .Mysqlx.Datatypes.Scalar.Octets v_octets = 5; + * @return Whether the vOctets field is set. + */ + boolean hasVOctets(); + /** + * 
+     * 4 is unused, was Null which doesn't have a storage anymore
+     *
+ * + * optional .Mysqlx.Datatypes.Scalar.Octets v_octets = 5; + * @return The vOctets. + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets getVOctets(); + /** + * 
+     * 4 is unused, was Null which doesn't have a storage anymore
+     *
+ * + * optional .Mysqlx.Datatypes.Scalar.Octets v_octets = 5; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.OctetsOrBuilder getVOctetsOrBuilder(); + + /** + * optional double v_double = 6; + * @return Whether the vDouble field is set. + */ + boolean hasVDouble(); + /** + * optional double v_double = 6; + * @return The vDouble. + */ + double getVDouble(); + + /** + * optional float v_float = 7; + * @return Whether the vFloat field is set. + */ + boolean hasVFloat(); + /** + * optional float v_float = 7; + * @return The vFloat. + */ + float getVFloat(); + + /** + * optional bool v_bool = 8; + * @return Whether the vBool field is set. + */ + boolean hasVBool(); + /** + * optional bool v_bool = 8; + * @return The vBool. + */ + boolean getVBool(); + + /** + * optional .Mysqlx.Datatypes.Scalar.String v_string = 9; + * @return Whether the vString field is set. + */ + boolean hasVString(); + /** + * optional .Mysqlx.Datatypes.Scalar.String v_string = 9; + * @return The vString. + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String getVString(); + /** + * optional .Mysqlx.Datatypes.Scalar.String v_string = 9; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.StringOrBuilder getVStringOrBuilder(); + } + /** + * 
+   * a scalar
+   *
+ * + * Protobuf type {@code Mysqlx.Datatypes.Scalar} + */ + public static final class Scalar extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Datatypes.Scalar) + ScalarOrBuilder { + private static final long serialVersionUID = 0L; + // Use Scalar.newBuilder() to construct. + private Scalar(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Scalar() { + type_ = 1; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Scalar(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Scalar( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Type value = com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Type.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(1, rawValue); + } else { + bitField0_ |= 0x00000001; + type_ = rawValue; + } + break; + } + case 16: { + bitField0_ |= 0x00000002; + vSignedInt_ = input.readSInt64(); + break; + } + case 24: { + bitField0_ |= 0x00000004; + vUnsignedInt_ = input.readUInt64(); + break; + } + case 42: { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) != 0)) { + subBuilder = vOctets_.toBuilder(); + } + vOctets_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(vOctets_); + vOctets_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + break; + } + case 49: { + bitField0_ |= 0x00000010; + vDouble_ = input.readDouble(); + break; + } + case 61: { + bitField0_ |= 0x00000020; + vFloat_ = input.readFloat(); + break; + } + case 64: { + bitField0_ |= 0x00000040; + vBool_ = input.readBool(); + break; + } + case 74: { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String.Builder subBuilder = null; + if (((bitField0_ & 0x00000080) != 0)) { + subBuilder = vString_.toBuilder(); + } + vString_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(vString_); + vString_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000080; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Scalar_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Scalar_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.class, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder.class); + } + + /** + * Protobuf enum {@code Mysqlx.Datatypes.Scalar.Type} + */ + public enum Type + implements com.google.protobuf.ProtocolMessageEnum { + /** + * V_SINT = 1; + */ + V_SINT(1), + /** + * V_UINT = 2; + */ + V_UINT(2), + /** + * V_NULL = 3; + */ + V_NULL(3), + /** + * V_OCTETS = 4; + */ + V_OCTETS(4), + /** + * V_DOUBLE = 5; + */ + V_DOUBLE(5), + /** + * V_FLOAT = 6; + */ + V_FLOAT(6), + /** + * V_BOOL = 7; + */ + V_BOOL(7), + /** + * V_STRING = 8; + */ + V_STRING(8), + ; + + /** + * V_SINT = 1; + */ + public static final int V_SINT_VALUE = 1; + /** + * V_UINT = 2; + */ + public static final int V_UINT_VALUE = 2; + /** + * V_NULL = 3; + */ + public static final int V_NULL_VALUE = 3; + /** + * V_OCTETS = 4; + */ + public static final int V_OCTETS_VALUE = 4; + /** + * V_DOUBLE = 5; + */ + public static final int V_DOUBLE_VALUE = 5; + /** + * V_FLOAT = 6; + */ + public static final int V_FLOAT_VALUE = 6; + /** + * V_BOOL = 7; + */ + public static final int V_BOOL_VALUE = 7; + /** + * V_STRING = 8; + */ + public static final int V_STRING_VALUE = 8; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static Type valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static Type forNumber(int value) { + switch (value) { + case 1: return V_SINT; + case 2: return V_UINT; + case 3: return V_NULL; + case 4: return V_OCTETS; + case 5: return V_DOUBLE; + case 6: return V_FLOAT; + case 7: return V_BOOL; + case 8: return V_STRING; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + Type> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Type findValueByNumber(int number) { + return Type.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDescriptor().getEnumTypes().get(0); + } + + private static final Type[] VALUES = values(); + + public static Type valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private Type(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Datatypes.Scalar.Type) + } + + public interface StringOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Datatypes.Scalar.String) + com.google.protobuf.MessageOrBuilder { + + /** + * required bytes value = 1; + * @return Whether the value field is set. + */ + boolean hasValue(); + /** + * required bytes value = 1; + * @return The value. + */ + com.google.protobuf.ByteString getValue(); + + /** + * optional uint64 collation = 2; + * @return Whether the collation field is set. + */ + boolean hasCollation(); + /** + * optional uint64 collation = 2; + * @return The collation. + */ + long getCollation(); + } + /** + * 
+     ** a string with a charset/collation 
+     *
+ * + * Protobuf type {@code Mysqlx.Datatypes.Scalar.String} + */ + public static final class String extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Datatypes.Scalar.String) + StringOrBuilder { + private static final long serialVersionUID = 0L; + // Use String.newBuilder() to construct. + private String(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private String() { + value_ = com.google.protobuf.ByteString.EMPTY; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new String(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private String( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + bitField0_ |= 0x00000001; + value_ = input.readBytes(); + break; + } + case 16: { + bitField0_ |= 0x00000002; + collation_ = input.readUInt64(); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Scalar_String_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Scalar_String_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String.class, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String.Builder.class); + } + + private int bitField0_; + public static final int VALUE_FIELD_NUMBER = 1; + private com.google.protobuf.ByteString value_; + /** + * required bytes value = 1; + * @return Whether the value field is set. + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required bytes value = 1; + * @return The value. + */ + public com.google.protobuf.ByteString getValue() { + return value_; + } + + public static final int COLLATION_FIELD_NUMBER = 2; + private long collation_; + /** + * optional uint64 collation = 2; + * @return Whether the collation field is set. + */ + public boolean hasCollation() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional uint64 collation = 2; + * @return The collation. + */ + public long getCollation() { + return collation_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasValue()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeBytes(1, value_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeUInt64(2, collation_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, value_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt64Size(2, collation_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String other = (com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String) obj; + + if (hasValue() != other.hasValue()) return false; + if (hasValue()) { + if (!getValue() + .equals(other.getValue())) return false; + } + if (hasCollation() != other.hasCollation()) return false; + if (hasCollation()) { + if (getCollation() + != other.getCollation()) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasValue()) { + hash = (37 * hash) + VALUE_FIELD_NUMBER; + hash = (53 * hash) + getValue().hashCode(); + } + if (hasCollation()) { + hash = (37 * hash) + COLLATION_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getCollation()); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+       ** a string with a charset/collation 
+       *
+ * + * Protobuf type {@code Mysqlx.Datatypes.Scalar.String} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Datatypes.Scalar.String) + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.StringOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Scalar_String_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Scalar_String_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String.class, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + value_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000001); + collation_ = 0L; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Scalar_String_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String build() { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String buildPartial() { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String result = new com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.value_ = value_; + if (((from_bitField0_ & 0x00000002) != 0)) { + result.collation_ = collation_; + to_bitField0_ |= 0x00000002; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String other) { + if (other == com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String.getDefaultInstance()) return this; + if (other.hasValue()) { + setValue(other.getValue()); + } + if (other.hasCollation()) { + setCollation(other.getCollation()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasValue()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private com.google.protobuf.ByteString value_ = com.google.protobuf.ByteString.EMPTY; + /** + * required bytes value = 1; + * @return Whether the value field is set. + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required bytes value = 1; + * @return The value. + */ + public com.google.protobuf.ByteString getValue() { + return value_; + } + /** + * required bytes value = 1; + * @param value The value to set. + * @return This builder for chaining. + */ + public Builder setValue(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + value_ = value; + onChanged(); + return this; + } + /** + * required bytes value = 1; + * @return This builder for chaining. + */ + public Builder clearValue() { + bitField0_ = (bitField0_ & ~0x00000001); + value_ = getDefaultInstance().getValue(); + onChanged(); + return this; + } + + private long collation_ ; + /** + * optional uint64 collation = 2; + * @return Whether the collation field is set. + */ + public boolean hasCollation() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional uint64 collation = 2; + * @return The collation. + */ + public long getCollation() { + return collation_; + } + /** + * optional uint64 collation = 2; + * @param value The collation to set. + * @return This builder for chaining. + */ + public Builder setCollation(long value) { + bitField0_ |= 0x00000002; + collation_ = value; + onChanged(); + return this; + } + /** + * optional uint64 collation = 2; + * @return This builder for chaining. + */ + public Builder clearCollation() { + bitField0_ = (bitField0_ & ~0x00000002); + collation_ = 0L; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Datatypes.Scalar.String) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Datatypes.Scalar.String) + private static final com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String(); + } + + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public String parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new String(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface OctetsOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Datatypes.Scalar.Octets) + com.google.protobuf.MessageOrBuilder { + + /** + * required bytes value = 1; + * @return Whether the value field is set. + */ + boolean hasValue(); + /** + * required bytes value = 1; + * @return The value. + */ + com.google.protobuf.ByteString getValue(); + + /** + * optional uint32 content_type = 2; + * @return Whether the contentType field is set. + */ + boolean hasContentType(); + /** + * optional uint32 content_type = 2; + * @return The contentType. + */ + int getContentType(); + } + /** + * 
+     ** an opaque octet sequence, with an optional content_type
+     *See @ref Mysqlx::Resultset::ContentType_BYTES for list of known values. 
+     *
+ * + * Protobuf type {@code Mysqlx.Datatypes.Scalar.Octets} + */ + public static final class Octets extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Datatypes.Scalar.Octets) + OctetsOrBuilder { + private static final long serialVersionUID = 0L; + // Use Octets.newBuilder() to construct. + private Octets(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Octets() { + value_ = com.google.protobuf.ByteString.EMPTY; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Octets(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Octets( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + bitField0_ |= 0x00000001; + value_ = input.readBytes(); + break; + } + case 16: { + bitField0_ |= 0x00000002; + contentType_ = input.readUInt32(); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Scalar_Octets_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Scalar_Octets_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets.class, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets.Builder.class); + } + + private int bitField0_; + public static final int VALUE_FIELD_NUMBER = 1; + private com.google.protobuf.ByteString value_; + /** + * required bytes value = 1; + * @return Whether the value field is set. + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required bytes value = 1; + * @return The value. + */ + public com.google.protobuf.ByteString getValue() { + return value_; + } + + public static final int CONTENT_TYPE_FIELD_NUMBER = 2; + private int contentType_; + /** + * optional uint32 content_type = 2; + * @return Whether the contentType field is set. + */ + public boolean hasContentType() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional uint32 content_type = 2; + * @return The contentType. + */ + public int getContentType() { + return contentType_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasValue()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeBytes(1, value_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeUInt32(2, contentType_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, value_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(2, contentType_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets other = (com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets) obj; + + if (hasValue() != other.hasValue()) return false; + if (hasValue()) { + if (!getValue() + .equals(other.getValue())) return false; + } + if (hasContentType() != other.hasContentType()) return false; + if (hasContentType()) { + if (getContentType() + != other.getContentType()) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasValue()) { + hash = (37 * hash) + VALUE_FIELD_NUMBER; + hash = (53 * hash) + getValue().hashCode(); + } + if (hasContentType()) { + hash = (37 * hash) + CONTENT_TYPE_FIELD_NUMBER; + hash = (53 * hash) + getContentType(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+       ** an opaque octet sequence, with an optional content_type
+       *See @ref Mysqlx::Resultset::ContentType_BYTES for list of known values. 
+       *
+ * + * Protobuf type {@code Mysqlx.Datatypes.Scalar.Octets} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Datatypes.Scalar.Octets) + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.OctetsOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Scalar_Octets_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Scalar_Octets_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets.class, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + value_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000001); + contentType_ = 0; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Scalar_Octets_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets build() { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets buildPartial() { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets result = new com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.value_ = value_; + if (((from_bitField0_ & 0x00000002) != 0)) { + result.contentType_ = contentType_; + to_bitField0_ |= 0x00000002; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets other) { + if (other == com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets.getDefaultInstance()) return this; + if (other.hasValue()) { + setValue(other.getValue()); + } + if (other.hasContentType()) { + setContentType(other.getContentType()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasValue()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private com.google.protobuf.ByteString value_ = com.google.protobuf.ByteString.EMPTY; + /** + * required bytes value = 1; + * @return Whether the value field is set. + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required bytes value = 1; + * @return The value. + */ + public com.google.protobuf.ByteString getValue() { + return value_; + } + /** + * required bytes value = 1; + * @param value The value to set. + * @return This builder for chaining. + */ + public Builder setValue(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + value_ = value; + onChanged(); + return this; + } + /** + * required bytes value = 1; + * @return This builder for chaining. + */ + public Builder clearValue() { + bitField0_ = (bitField0_ & ~0x00000001); + value_ = getDefaultInstance().getValue(); + onChanged(); + return this; + } + + private int contentType_ ; + /** + * optional uint32 content_type = 2; + * @return Whether the contentType field is set. + */ + public boolean hasContentType() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional uint32 content_type = 2; + * @return The contentType. + */ + public int getContentType() { + return contentType_; + } + /** + * optional uint32 content_type = 2; + * @param value The contentType to set. + * @return This builder for chaining. + */ + public Builder setContentType(int value) { + bitField0_ |= 0x00000002; + contentType_ = value; + onChanged(); + return this; + } + /** + * optional uint32 content_type = 2; + * @return This builder for chaining. + */ + public Builder clearContentType() { + bitField0_ = (bitField0_ & ~0x00000002); + contentType_ = 0; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Datatypes.Scalar.Octets) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Datatypes.Scalar.Octets) + private static final com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets(); + } + + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Octets parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Octets(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private int bitField0_; + public static final int TYPE_FIELD_NUMBER = 1; + private int type_; + /** + * required .Mysqlx.Datatypes.Scalar.Type type = 1; + * @return Whether the type field is set. + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required .Mysqlx.Datatypes.Scalar.Type type = 1; + * @return The type. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Type getType() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Type result = com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Type.valueOf(type_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Type.V_SINT : result; + } + + public static final int V_SIGNED_INT_FIELD_NUMBER = 2; + private long vSignedInt_; + /** + * optional sint64 v_signed_int = 2; + * @return Whether the vSignedInt field is set. + */ + public boolean hasVSignedInt() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional sint64 v_signed_int = 2; + * @return The vSignedInt. + */ + public long getVSignedInt() { + return vSignedInt_; + } + + public static final int V_UNSIGNED_INT_FIELD_NUMBER = 3; + private long vUnsignedInt_; + /** + * optional uint64 v_unsigned_int = 3; + * @return Whether the vUnsignedInt field is set. + */ + public boolean hasVUnsignedInt() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * optional uint64 v_unsigned_int = 3; + * @return The vUnsignedInt. + */ + public long getVUnsignedInt() { + return vUnsignedInt_; + } + + public static final int V_OCTETS_FIELD_NUMBER = 5; + private com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets vOctets_; + /** + * 
+     * 4 is unused, was Null which doesn't have a storage anymore
+     *
+ * + * optional .Mysqlx.Datatypes.Scalar.Octets v_octets = 5; + * @return Whether the vOctets field is set. + */ + public boolean hasVOctets() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * 
+     * 4 is unused, was Null which doesn't have a storage anymore
+     *
+ * + * optional .Mysqlx.Datatypes.Scalar.Octets v_octets = 5; + * @return The vOctets. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets getVOctets() { + return vOctets_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets.getDefaultInstance() : vOctets_; + } + /** + * 
+     * 4 is unused, was Null which doesn't have a storage anymore
+     *
+ * + * optional .Mysqlx.Datatypes.Scalar.Octets v_octets = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.OctetsOrBuilder getVOctetsOrBuilder() { + return vOctets_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets.getDefaultInstance() : vOctets_; + } + + public static final int V_DOUBLE_FIELD_NUMBER = 6; + private double vDouble_; + /** + * optional double v_double = 6; + * @return Whether the vDouble field is set. + */ + public boolean hasVDouble() { + return ((bitField0_ & 0x00000010) != 0); + } + /** + * optional double v_double = 6; + * @return The vDouble. + */ + public double getVDouble() { + return vDouble_; + } + + public static final int V_FLOAT_FIELD_NUMBER = 7; + private float vFloat_; + /** + * optional float v_float = 7; + * @return Whether the vFloat field is set. + */ + public boolean hasVFloat() { + return ((bitField0_ & 0x00000020) != 0); + } + /** + * optional float v_float = 7; + * @return The vFloat. + */ + public float getVFloat() { + return vFloat_; + } + + public static final int V_BOOL_FIELD_NUMBER = 8; + private boolean vBool_; + /** + * optional bool v_bool = 8; + * @return Whether the vBool field is set. + */ + public boolean hasVBool() { + return ((bitField0_ & 0x00000040) != 0); + } + /** + * optional bool v_bool = 8; + * @return The vBool. + */ + public boolean getVBool() { + return vBool_; + } + + public static final int V_STRING_FIELD_NUMBER = 9; + private com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String vString_; + /** + * optional .Mysqlx.Datatypes.Scalar.String v_string = 9; + * @return Whether the vString field is set. + */ + public boolean hasVString() { + return ((bitField0_ & 0x00000080) != 0); + } + /** + * optional .Mysqlx.Datatypes.Scalar.String v_string = 9; + * @return The vString. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String getVString() { + return vString_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String.getDefaultInstance() : vString_; + } + /** + * optional .Mysqlx.Datatypes.Scalar.String v_string = 9; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.StringOrBuilder getVStringOrBuilder() { + return vString_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String.getDefaultInstance() : vString_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasType()) { + memoizedIsInitialized = 0; + return false; + } + if (hasVOctets()) { + if (!getVOctets().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasVString()) { + if (!getVString().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeEnum(1, type_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeSInt64(2, vSignedInt_); + } + if (((bitField0_ & 0x00000004) != 0)) { + output.writeUInt64(3, vUnsignedInt_); + } + if (((bitField0_ & 0x00000008) != 0)) { + output.writeMessage(5, getVOctets()); + } + if (((bitField0_ & 0x00000010) != 0)) { + output.writeDouble(6, vDouble_); + } + if (((bitField0_ & 0x00000020) != 0)) { + output.writeFloat(7, vFloat_); + } + if (((bitField0_ & 0x00000040) != 0)) { + output.writeBool(8, vBool_); + } + if (((bitField0_ & 0x00000080) != 0)) { + output.writeMessage(9, getVString()); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(1, type_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeSInt64Size(2, vSignedInt_); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt64Size(3, vUnsignedInt_); + } + if (((bitField0_ & 0x00000008) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(5, getVOctets()); + } + if (((bitField0_ & 0x00000010) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeDoubleSize(6, vDouble_); + } + if (((bitField0_ & 0x00000020) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeFloatSize(7, vFloat_); + } + if (((bitField0_ & 0x00000040) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(8, vBool_); + } + if (((bitField0_ & 0x00000080) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(9, getVString()); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar other = (com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar) obj; + + if (hasType() != other.hasType()) return false; + if (hasType()) { + if (type_ != other.type_) return false; + } + if (hasVSignedInt() != other.hasVSignedInt()) return false; + if (hasVSignedInt()) { + if (getVSignedInt() + != other.getVSignedInt()) return false; + } + if (hasVUnsignedInt() != other.hasVUnsignedInt()) return false; + if (hasVUnsignedInt()) { + if (getVUnsignedInt() + != other.getVUnsignedInt()) return false; + } + if (hasVOctets() != other.hasVOctets()) return false; + if (hasVOctets()) { + if (!getVOctets() + .equals(other.getVOctets())) return false; + } + if (hasVDouble() != other.hasVDouble()) return false; + if (hasVDouble()) { + if (java.lang.Double.doubleToLongBits(getVDouble()) + != java.lang.Double.doubleToLongBits( + other.getVDouble())) return false; + } + if (hasVFloat() != other.hasVFloat()) return false; + if (hasVFloat()) { + if (java.lang.Float.floatToIntBits(getVFloat()) + != java.lang.Float.floatToIntBits( + other.getVFloat())) return false; + } + if (hasVBool() != other.hasVBool()) return false; + if (hasVBool()) { + if (getVBool() + != other.getVBool()) return false; + } + if (hasVString() != other.hasVString()) return false; + if (hasVString()) { + if (!getVString() + .equals(other.getVString())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasType()) { + hash = (37 * hash) + TYPE_FIELD_NUMBER; + hash = (53 * hash) + type_; + } + if (hasVSignedInt()) { + hash = (37 * hash) + V_SIGNED_INT_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getVSignedInt()); + } + if (hasVUnsignedInt()) { + hash = (37 * hash) + V_UNSIGNED_INT_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getVUnsignedInt()); + } + if (hasVOctets()) { + hash = (37 * hash) + V_OCTETS_FIELD_NUMBER; + hash = (53 * hash) + getVOctets().hashCode(); + } + if (hasVDouble()) { + hash = (37 * hash) + V_DOUBLE_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + java.lang.Double.doubleToLongBits(getVDouble())); + } + if (hasVFloat()) { + hash = (37 * hash) + V_FLOAT_FIELD_NUMBER; + hash = (53 * hash) + java.lang.Float.floatToIntBits( + getVFloat()); + } + if (hasVBool()) { + hash = (37 * hash) + V_BOOL_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getVBool()); + } + if (hasVString()) { + hash = (37 * hash) + V_STRING_FIELD_NUMBER; + hash = (53 * hash) + getVString().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     * a scalar
+     *
+ * + * Protobuf type {@code Mysqlx.Datatypes.Scalar} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Datatypes.Scalar) + com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Scalar_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Scalar_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.class, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getVOctetsFieldBuilder(); + getVStringFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + type_ = 1; + bitField0_ = (bitField0_ & ~0x00000001); + vSignedInt_ = 0L; + bitField0_ = (bitField0_ & ~0x00000002); + vUnsignedInt_ = 0L; + bitField0_ = (bitField0_ & ~0x00000004); + if (vOctetsBuilder_ == null) { + vOctets_ = null; + } else { + vOctetsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + vDouble_ = 0D; + bitField0_ = (bitField0_ & ~0x00000010); + vFloat_ = 0F; + bitField0_ = (bitField0_ & ~0x00000020); + vBool_ = false; + bitField0_ = (bitField0_ & ~0x00000040); + if (vStringBuilder_ == null) { + vString_ = null; + } else { + vStringBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000080); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Scalar_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar build() { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar buildPartial() { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar result = new com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.type_ = type_; + if (((from_bitField0_ & 0x00000002) != 0)) { + result.vSignedInt_ = vSignedInt_; + to_bitField0_ |= 0x00000002; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + result.vUnsignedInt_ = vUnsignedInt_; + to_bitField0_ |= 0x00000004; + } + if (((from_bitField0_ & 0x00000008) != 0)) { + if (vOctetsBuilder_ == null) { + result.vOctets_ = vOctets_; + } else { + result.vOctets_ = vOctetsBuilder_.build(); + } + to_bitField0_ |= 0x00000008; + } + if (((from_bitField0_ & 0x00000010) != 0)) { + result.vDouble_ = vDouble_; + to_bitField0_ |= 0x00000010; + } + if (((from_bitField0_ & 0x00000020) != 0)) { + result.vFloat_ = vFloat_; + to_bitField0_ |= 0x00000020; + } + if (((from_bitField0_ & 0x00000040) != 0)) { + result.vBool_ = vBool_; + to_bitField0_ |= 0x00000040; + } + if (((from_bitField0_ & 0x00000080) != 0)) { + if (vStringBuilder_ == null) { + result.vString_ = vString_; + } else { + result.vString_ = vStringBuilder_.build(); + } + to_bitField0_ |= 0x00000080; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar other) { + if (other == com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance()) return this; + if (other.hasType()) { + setType(other.getType()); + } + if (other.hasVSignedInt()) { + setVSignedInt(other.getVSignedInt()); + } + if (other.hasVUnsignedInt()) { + setVUnsignedInt(other.getVUnsignedInt()); + } + if (other.hasVOctets()) { + mergeVOctets(other.getVOctets()); + } + if (other.hasVDouble()) { + setVDouble(other.getVDouble()); + } + if (other.hasVFloat()) { + setVFloat(other.getVFloat()); + } + if (other.hasVBool()) { + setVBool(other.getVBool()); + } + if (other.hasVString()) { + mergeVString(other.getVString()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasType()) { + return false; + } + if (hasVOctets()) { + if (!getVOctets().isInitialized()) { + return false; + } + } + if (hasVString()) { + if (!getVString().isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int type_ = 1; + /** + * required .Mysqlx.Datatypes.Scalar.Type type = 1; + * @return Whether the type field is set. + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required .Mysqlx.Datatypes.Scalar.Type type = 1; + * @return The type. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Type getType() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Type result = com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Type.valueOf(type_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Type.V_SINT : result; + } + /** + * required .Mysqlx.Datatypes.Scalar.Type type = 1; + * @param value The type to set. + * @return This builder for chaining. + */ + public Builder setType(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Type value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + type_ = value.getNumber(); + onChanged(); + return this; + } + /** + * required .Mysqlx.Datatypes.Scalar.Type type = 1; + * @return This builder for chaining. + */ + public Builder clearType() { + bitField0_ = (bitField0_ & ~0x00000001); + type_ = 1; + onChanged(); + return this; + } + + private long vSignedInt_ ; + /** + * optional sint64 v_signed_int = 2; + * @return Whether the vSignedInt field is set. + */ + public boolean hasVSignedInt() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional sint64 v_signed_int = 2; + * @return The vSignedInt. + */ + public long getVSignedInt() { + return vSignedInt_; + } + /** + * optional sint64 v_signed_int = 2; + * @param value The vSignedInt to set. + * @return This builder for chaining. + */ + public Builder setVSignedInt(long value) { + bitField0_ |= 0x00000002; + vSignedInt_ = value; + onChanged(); + return this; + } + /** + * optional sint64 v_signed_int = 2; + * @return This builder for chaining. + */ + public Builder clearVSignedInt() { + bitField0_ = (bitField0_ & ~0x00000002); + vSignedInt_ = 0L; + onChanged(); + return this; + } + + private long vUnsignedInt_ ; + /** + * optional uint64 v_unsigned_int = 3; + * @return Whether the vUnsignedInt field is set. + */ + public boolean hasVUnsignedInt() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * optional uint64 v_unsigned_int = 3; + * @return The vUnsignedInt. + */ + public long getVUnsignedInt() { + return vUnsignedInt_; + } + /** + * optional uint64 v_unsigned_int = 3; + * @param value The vUnsignedInt to set. + * @return This builder for chaining. + */ + public Builder setVUnsignedInt(long value) { + bitField0_ |= 0x00000004; + vUnsignedInt_ = value; + onChanged(); + return this; + } + /** + * optional uint64 v_unsigned_int = 3; + * @return This builder for chaining. + */ + public Builder clearVUnsignedInt() { + bitField0_ = (bitField0_ & ~0x00000004); + vUnsignedInt_ = 0L; + onChanged(); + return this; + } + + private com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets vOctets_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.OctetsOrBuilder> vOctetsBuilder_; + /** + * 
+       * 4 is unused, was Null which doesn't have a storage anymore
+       *
+ * + * optional .Mysqlx.Datatypes.Scalar.Octets v_octets = 5; + * @return Whether the vOctets field is set. + */ + public boolean hasVOctets() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * 
+       * 4 is unused, was Null which doesn't have a storage anymore
+       *
+ * + * optional .Mysqlx.Datatypes.Scalar.Octets v_octets = 5; + * @return The vOctets. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets getVOctets() { + if (vOctetsBuilder_ == null) { + return vOctets_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets.getDefaultInstance() : vOctets_; + } else { + return vOctetsBuilder_.getMessage(); + } + } + /** + * 
+       * 4 is unused, was Null which doesn't have a storage anymore
+       *
+ * + * optional .Mysqlx.Datatypes.Scalar.Octets v_octets = 5; + */ + public Builder setVOctets(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets value) { + if (vOctetsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + vOctets_ = value; + onChanged(); + } else { + vOctetsBuilder_.setMessage(value); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * 
+       * 4 is unused, was Null which doesn't have a storage anymore
+       *
+ * + * optional .Mysqlx.Datatypes.Scalar.Octets v_octets = 5; + */ + public Builder setVOctets( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets.Builder builderForValue) { + if (vOctetsBuilder_ == null) { + vOctets_ = builderForValue.build(); + onChanged(); + } else { + vOctetsBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * 
+       * 4 is unused, was Null which doesn't have a storage anymore
+       *
+ * + * optional .Mysqlx.Datatypes.Scalar.Octets v_octets = 5; + */ + public Builder mergeVOctets(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets value) { + if (vOctetsBuilder_ == null) { + if (((bitField0_ & 0x00000008) != 0) && + vOctets_ != null && + vOctets_ != com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets.getDefaultInstance()) { + vOctets_ = + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets.newBuilder(vOctets_).mergeFrom(value).buildPartial(); + } else { + vOctets_ = value; + } + onChanged(); + } else { + vOctetsBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * 
+       * 4 is unused, was Null which doesn't have a storage anymore
+       *
+ * + * optional .Mysqlx.Datatypes.Scalar.Octets v_octets = 5; + */ + public Builder clearVOctets() { + if (vOctetsBuilder_ == null) { + vOctets_ = null; + onChanged(); + } else { + vOctetsBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + /** + * 
+       * 4 is unused, was Null which doesn't have a storage anymore
+       *
+ * + * optional .Mysqlx.Datatypes.Scalar.Octets v_octets = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets.Builder getVOctetsBuilder() { + bitField0_ |= 0x00000008; + onChanged(); + return getVOctetsFieldBuilder().getBuilder(); + } + /** + * 
+       * 4 is unused, was Null which doesn't have a storage anymore
+       *
+ * + * optional .Mysqlx.Datatypes.Scalar.Octets v_octets = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.OctetsOrBuilder getVOctetsOrBuilder() { + if (vOctetsBuilder_ != null) { + return vOctetsBuilder_.getMessageOrBuilder(); + } else { + return vOctets_ == null ? + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets.getDefaultInstance() : vOctets_; + } + } + /** + * 
+       * 4 is unused, was Null which doesn't have a storage anymore
+       *
+ * + * optional .Mysqlx.Datatypes.Scalar.Octets v_octets = 5; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.OctetsOrBuilder> + getVOctetsFieldBuilder() { + if (vOctetsBuilder_ == null) { + vOctetsBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Octets.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.OctetsOrBuilder>( + getVOctets(), + getParentForChildren(), + isClean()); + vOctets_ = null; + } + return vOctetsBuilder_; + } + + private double vDouble_ ; + /** + * optional double v_double = 6; + * @return Whether the vDouble field is set. + */ + public boolean hasVDouble() { + return ((bitField0_ & 0x00000010) != 0); + } + /** + * optional double v_double = 6; + * @return The vDouble. + */ + public double getVDouble() { + return vDouble_; + } + /** + * optional double v_double = 6; + * @param value The vDouble to set. + * @return This builder for chaining. + */ + public Builder setVDouble(double value) { + bitField0_ |= 0x00000010; + vDouble_ = value; + onChanged(); + return this; + } + /** + * optional double v_double = 6; + * @return This builder for chaining. + */ + public Builder clearVDouble() { + bitField0_ = (bitField0_ & ~0x00000010); + vDouble_ = 0D; + onChanged(); + return this; + } + + private float vFloat_ ; + /** + * optional float v_float = 7; + * @return Whether the vFloat field is set. + */ + public boolean hasVFloat() { + return ((bitField0_ & 0x00000020) != 0); + } + /** + * optional float v_float = 7; + * @return The vFloat. + */ + public float getVFloat() { + return vFloat_; + } + /** + * optional float v_float = 7; + * @param value The vFloat to set. + * @return This builder for chaining. + */ + public Builder setVFloat(float value) { + bitField0_ |= 0x00000020; + vFloat_ = value; + onChanged(); + return this; + } + /** + * optional float v_float = 7; + * @return This builder for chaining. + */ + public Builder clearVFloat() { + bitField0_ = (bitField0_ & ~0x00000020); + vFloat_ = 0F; + onChanged(); + return this; + } + + private boolean vBool_ ; + /** + * optional bool v_bool = 8; + * @return Whether the vBool field is set. + */ + public boolean hasVBool() { + return ((bitField0_ & 0x00000040) != 0); + } + /** + * optional bool v_bool = 8; + * @return The vBool. + */ + public boolean getVBool() { + return vBool_; + } + /** + * optional bool v_bool = 8; + * @param value The vBool to set. + * @return This builder for chaining. + */ + public Builder setVBool(boolean value) { + bitField0_ |= 0x00000040; + vBool_ = value; + onChanged(); + return this; + } + /** + * optional bool v_bool = 8; + * @return This builder for chaining. + */ + public Builder clearVBool() { + bitField0_ = (bitField0_ & ~0x00000040); + vBool_ = false; + onChanged(); + return this; + } + + private com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String vString_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.StringOrBuilder> vStringBuilder_; + /** + * optional .Mysqlx.Datatypes.Scalar.String v_string = 9; + * @return Whether the vString field is set. + */ + public boolean hasVString() { + return ((bitField0_ & 0x00000080) != 0); + } + /** + * optional .Mysqlx.Datatypes.Scalar.String v_string = 9; + * @return The vString. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String getVString() { + if (vStringBuilder_ == null) { + return vString_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String.getDefaultInstance() : vString_; + } else { + return vStringBuilder_.getMessage(); + } + } + /** + * optional .Mysqlx.Datatypes.Scalar.String v_string = 9; + */ + public Builder setVString(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String value) { + if (vStringBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + vString_ = value; + onChanged(); + } else { + vStringBuilder_.setMessage(value); + } + bitField0_ |= 0x00000080; + return this; + } + /** + * optional .Mysqlx.Datatypes.Scalar.String v_string = 9; + */ + public Builder setVString( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String.Builder builderForValue) { + if (vStringBuilder_ == null) { + vString_ = builderForValue.build(); + onChanged(); + } else { + vStringBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000080; + return this; + } + /** + * optional .Mysqlx.Datatypes.Scalar.String v_string = 9; + */ + public Builder mergeVString(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String value) { + if (vStringBuilder_ == null) { + if (((bitField0_ & 0x00000080) != 0) && + vString_ != null && + vString_ != com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String.getDefaultInstance()) { + vString_ = + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String.newBuilder(vString_).mergeFrom(value).buildPartial(); + } else { + vString_ = value; + } + onChanged(); + } else { + vStringBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000080; + return this; + } + /** + * optional .Mysqlx.Datatypes.Scalar.String v_string = 9; + */ + public Builder clearVString() { + if (vStringBuilder_ == null) { + vString_ = null; + onChanged(); + } else { + vStringBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000080); + return this; + } + /** + * optional .Mysqlx.Datatypes.Scalar.String v_string = 9; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String.Builder getVStringBuilder() { + bitField0_ |= 0x00000080; + onChanged(); + return getVStringFieldBuilder().getBuilder(); + } + /** + * optional .Mysqlx.Datatypes.Scalar.String v_string = 9; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.StringOrBuilder getVStringOrBuilder() { + if (vStringBuilder_ != null) { + return vStringBuilder_.getMessageOrBuilder(); + } else { + return vString_ == null ? + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String.getDefaultInstance() : vString_; + } + } + /** + * optional .Mysqlx.Datatypes.Scalar.String v_string = 9; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.StringOrBuilder> + getVStringFieldBuilder() { + if (vStringBuilder_ == null) { + vStringBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.String.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.StringOrBuilder>( + getVString(), + getParentForChildren(), + isClean()); + vString_ = null; + } + return vStringBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Datatypes.Scalar) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Datatypes.Scalar) + private static final com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar(); + } + + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Scalar parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Scalar(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ObjectOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Datatypes.Object) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + java.util.List + getFldList(); + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField getFld(int index); + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + int getFldCount(); + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + java.util.List + getFldOrBuilderList(); + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectFieldOrBuilder getFldOrBuilder( + int index); + } + /** + * 
+   **
+   *An object
+   *
+ * + * Protobuf type {@code Mysqlx.Datatypes.Object} + */ + public static final class Object extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Datatypes.Object) + ObjectOrBuilder { + private static final long serialVersionUID = 0L; + // Use Object.newBuilder() to construct. + private Object(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Object() { + fld_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Object(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Object( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + if (!((mutable_bitField0_ & 0x00000001) != 0)) { + fld_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + fld_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField.PARSER, extensionRegistry)); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000001) != 0)) { + fld_ = java.util.Collections.unmodifiableList(fld_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Object_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Object_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.class, com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.Builder.class); + } + + public interface ObjectFieldOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Datatypes.Object.ObjectField) + com.google.protobuf.MessageOrBuilder { + + /** + * required string key = 1; + * @return Whether the key field is set. + */ + boolean hasKey(); + /** + * required string key = 1; + * @return The key. + */ + java.lang.String getKey(); + /** + * required string key = 1; + * @return The bytes for key. + */ + com.google.protobuf.ByteString + getKeyBytes(); + + /** + * required .Mysqlx.Datatypes.Any value = 2; + * @return Whether the value field is set. + */ + boolean hasValue(); + /** + * required .Mysqlx.Datatypes.Any value = 2; + * @return The value. + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any getValue(); + /** + * required .Mysqlx.Datatypes.Any value = 2; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder getValueOrBuilder(); + } + /** + * Protobuf type {@code Mysqlx.Datatypes.Object.ObjectField} + */ + public static final class ObjectField extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Datatypes.Object.ObjectField) + ObjectFieldOrBuilder { + private static final long serialVersionUID = 0L; + // Use ObjectField.newBuilder() to construct. + private ObjectField(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private ObjectField() { + key_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new ObjectField(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private ObjectField( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000001; + key_ = bs; + break; + } + case 18: { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) != 0)) { + subBuilder = value_.toBuilder(); + } + value_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(value_); + value_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Object_ObjectField_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Object_ObjectField_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField.class, com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField.Builder.class); + } + + private int bitField0_; + public static final int KEY_FIELD_NUMBER = 1; + private volatile java.lang.Object key_; + /** + * required string key = 1; + * @return Whether the key field is set. + */ + public boolean hasKey() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required string key = 1; + * @return The key. + */ + public java.lang.String getKey() { + java.lang.Object ref = key_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + key_ = s; + } + return s; + } + } + /** + * required string key = 1; + * @return The bytes for key. + */ + public com.google.protobuf.ByteString + getKeyBytes() { + java.lang.Object ref = key_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + key_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int VALUE_FIELD_NUMBER = 2; + private com.mysql.cj.x.protobuf.MysqlxDatatypes.Any value_; + /** + * required .Mysqlx.Datatypes.Any value = 2; + * @return Whether the value field is set. + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * required .Mysqlx.Datatypes.Any value = 2; + * @return The value. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any getValue() { + return value_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.getDefaultInstance() : value_; + } + /** + * required .Mysqlx.Datatypes.Any value = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder getValueOrBuilder() { + return value_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.getDefaultInstance() : value_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasKey()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasValue()) { + memoizedIsInitialized = 0; + return false; + } + if (!getValue().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, key_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeMessage(2, getValue()); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, key_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, getValue()); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField other = (com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField) obj; + + if (hasKey() != other.hasKey()) return false; + if (hasKey()) { + if (!getKey() + .equals(other.getKey())) return false; + } + if (hasValue() != other.hasValue()) return false; + if (hasValue()) { + if (!getValue() + .equals(other.getValue())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasKey()) { + hash = (37 * hash) + KEY_FIELD_NUMBER; + hash = (53 * hash) + getKey().hashCode(); + } + if (hasValue()) { + hash = (37 * hash) + VALUE_FIELD_NUMBER; + hash = (53 * hash) + getValue().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Mysqlx.Datatypes.Object.ObjectField} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Datatypes.Object.ObjectField) + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectFieldOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Object_ObjectField_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Object_ObjectField_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField.class, com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getValueFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + key_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + if (valueBuilder_ == null) { + value_ = null; + } else { + valueBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Object_ObjectField_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField build() { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField buildPartial() { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField result = new com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.key_ = key_; + if (((from_bitField0_ & 0x00000002) != 0)) { + if (valueBuilder_ == null) { + result.value_ = value_; + } else { + result.value_ = valueBuilder_.build(); + } + to_bitField0_ |= 0x00000002; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField other) { + if (other == com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField.getDefaultInstance()) return this; + if (other.hasKey()) { + bitField0_ |= 0x00000001; + key_ = other.key_; + onChanged(); + } + if (other.hasValue()) { + mergeValue(other.getValue()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasKey()) { + return false; + } + if (!hasValue()) { + return false; + } + if (!getValue().isInitialized()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object key_ = ""; + /** + * required string key = 1; + * @return Whether the key field is set. + */ + public boolean hasKey() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required string key = 1; + * @return The key. + */ + public java.lang.String getKey() { + java.lang.Object ref = key_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + key_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string key = 1; + * @return The bytes for key. + */ + public com.google.protobuf.ByteString + getKeyBytes() { + java.lang.Object ref = key_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + key_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * required string key = 1; + * @param value The key to set. + * @return This builder for chaining. + */ + public Builder setKey( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + key_ = value; + onChanged(); + return this; + } + /** + * required string key = 1; + * @return This builder for chaining. + */ + public Builder clearKey() { + bitField0_ = (bitField0_ & ~0x00000001); + key_ = getDefaultInstance().getKey(); + onChanged(); + return this; + } + /** + * required string key = 1; + * @param value The bytes for key to set. + * @return This builder for chaining. + */ + public Builder setKeyBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + key_ = value; + onChanged(); + return this; + } + + private com.mysql.cj.x.protobuf.MysqlxDatatypes.Any value_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder> valueBuilder_; + /** + * required .Mysqlx.Datatypes.Any value = 2; + * @return Whether the value field is set. + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * required .Mysqlx.Datatypes.Any value = 2; + * @return The value. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any getValue() { + if (valueBuilder_ == null) { + return value_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.getDefaultInstance() : value_; + } else { + return valueBuilder_.getMessage(); + } + } + /** + * required .Mysqlx.Datatypes.Any value = 2; + */ + public Builder setValue(com.mysql.cj.x.protobuf.MysqlxDatatypes.Any value) { + if (valueBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + value_ = value; + onChanged(); + } else { + valueBuilder_.setMessage(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * required .Mysqlx.Datatypes.Any value = 2; + */ + public Builder setValue( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder builderForValue) { + if (valueBuilder_ == null) { + value_ = builderForValue.build(); + onChanged(); + } else { + valueBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * required .Mysqlx.Datatypes.Any value = 2; + */ + public Builder mergeValue(com.mysql.cj.x.protobuf.MysqlxDatatypes.Any value) { + if (valueBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0) && + value_ != null && + value_ != com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.getDefaultInstance()) { + value_ = + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.newBuilder(value_).mergeFrom(value).buildPartial(); + } else { + value_ = value; + } + onChanged(); + } else { + valueBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * required .Mysqlx.Datatypes.Any value = 2; + */ + public Builder clearValue() { + if (valueBuilder_ == null) { + value_ = null; + onChanged(); + } else { + valueBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + /** + * required .Mysqlx.Datatypes.Any value = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder getValueBuilder() { + bitField0_ |= 0x00000002; + onChanged(); + return getValueFieldBuilder().getBuilder(); + } + /** + * required .Mysqlx.Datatypes.Any value = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder getValueOrBuilder() { + if (valueBuilder_ != null) { + return valueBuilder_.getMessageOrBuilder(); + } else { + return value_ == null ? + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.getDefaultInstance() : value_; + } + } + /** + * required .Mysqlx.Datatypes.Any value = 2; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder> + getValueFieldBuilder() { + if (valueBuilder_ == null) { + valueBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder>( + getValue(), + getParentForChildren(), + isClean()); + value_ = null; + } + return valueBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Datatypes.Object.ObjectField) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Datatypes.Object.ObjectField) + private static final com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField(); + } + + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public ObjectField parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new ObjectField(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public static final int FLD_FIELD_NUMBER = 1; + private java.util.List fld_; + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public java.util.List getFldList() { + return fld_; + } + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public java.util.List + getFldOrBuilderList() { + return fld_; + } + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public int getFldCount() { + return fld_.size(); + } + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField getFld(int index) { + return fld_.get(index); + } + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectFieldOrBuilder getFldOrBuilder( + int index) { + return fld_.get(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + for (int i = 0; i < getFldCount(); i++) { + if (!getFld(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < fld_.size(); i++) { + output.writeMessage(1, fld_.get(i)); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < fld_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, fld_.get(i)); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxDatatypes.Object)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object other = (com.mysql.cj.x.protobuf.MysqlxDatatypes.Object) obj; + + if (!getFldList() + .equals(other.getFldList())) return false; + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getFldCount() > 0) { + hash = (37 * hash) + FLD_FIELD_NUMBER; + hash = (53 * hash) + getFldList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxDatatypes.Object prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *An object
+     *
+ * + * Protobuf type {@code Mysqlx.Datatypes.Object} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Datatypes.Object) + com.mysql.cj.x.protobuf.MysqlxDatatypes.ObjectOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Object_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Object_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.class, com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getFldFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + if (fldBuilder_ == null) { + fld_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + } else { + fldBuilder_.clear(); + } + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Object_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Object getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Object build() { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Object buildPartial() { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object result = new com.mysql.cj.x.protobuf.MysqlxDatatypes.Object(this); + int from_bitField0_ = bitField0_; + if (fldBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0)) { + fld_ = java.util.Collections.unmodifiableList(fld_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.fld_ = fld_; + } else { + result.fld_ = fldBuilder_.build(); + } + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxDatatypes.Object) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxDatatypes.Object)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxDatatypes.Object other) { + if (other == com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.getDefaultInstance()) return this; + if (fldBuilder_ == null) { + if (!other.fld_.isEmpty()) { + if (fld_.isEmpty()) { + fld_ = other.fld_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureFldIsMutable(); + fld_.addAll(other.fld_); + } + onChanged(); + } + } else { + if (!other.fld_.isEmpty()) { + if (fldBuilder_.isEmpty()) { + fldBuilder_.dispose(); + fldBuilder_ = null; + fld_ = other.fld_; + bitField0_ = (bitField0_ & ~0x00000001); + fldBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getFldFieldBuilder() : null; + } else { + fldBuilder_.addAllMessages(other.fld_); + } + } + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + for (int i = 0; i < getFldCount(); i++) { + if (!getFld(i).isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxDatatypes.Object) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List fld_ = + java.util.Collections.emptyList(); + private void ensureFldIsMutable() { + if (!((bitField0_ & 0x00000001) != 0)) { + fld_ = new java.util.ArrayList(fld_); + bitField0_ |= 0x00000001; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField, com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectFieldOrBuilder> fldBuilder_; + + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public java.util.List getFldList() { + if (fldBuilder_ == null) { + return java.util.Collections.unmodifiableList(fld_); + } else { + return fldBuilder_.getMessageList(); + } + } + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public int getFldCount() { + if (fldBuilder_ == null) { + return fld_.size(); + } else { + return fldBuilder_.getCount(); + } + } + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField getFld(int index) { + if (fldBuilder_ == null) { + return fld_.get(index); + } else { + return fldBuilder_.getMessage(index); + } + } + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public Builder setFld( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField value) { + if (fldBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureFldIsMutable(); + fld_.set(index, value); + onChanged(); + } else { + fldBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public Builder setFld( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField.Builder builderForValue) { + if (fldBuilder_ == null) { + ensureFldIsMutable(); + fld_.set(index, builderForValue.build()); + onChanged(); + } else { + fldBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public Builder addFld(com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField value) { + if (fldBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureFldIsMutable(); + fld_.add(value); + onChanged(); + } else { + fldBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public Builder addFld( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField value) { + if (fldBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureFldIsMutable(); + fld_.add(index, value); + onChanged(); + } else { + fldBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public Builder addFld( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField.Builder builderForValue) { + if (fldBuilder_ == null) { + ensureFldIsMutable(); + fld_.add(builderForValue.build()); + onChanged(); + } else { + fldBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public Builder addFld( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField.Builder builderForValue) { + if (fldBuilder_ == null) { + ensureFldIsMutable(); + fld_.add(index, builderForValue.build()); + onChanged(); + } else { + fldBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public Builder addAllFld( + java.lang.Iterable values) { + if (fldBuilder_ == null) { + ensureFldIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, fld_); + onChanged(); + } else { + fldBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public Builder clearFld() { + if (fldBuilder_ == null) { + fld_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + } else { + fldBuilder_.clear(); + } + return this; + } + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public Builder removeFld(int index) { + if (fldBuilder_ == null) { + ensureFldIsMutable(); + fld_.remove(index); + onChanged(); + } else { + fldBuilder_.remove(index); + } + return this; + } + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField.Builder getFldBuilder( + int index) { + return getFldFieldBuilder().getBuilder(index); + } + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectFieldOrBuilder getFldOrBuilder( + int index) { + if (fldBuilder_ == null) { + return fld_.get(index); } else { + return fldBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public java.util.List + getFldOrBuilderList() { + if (fldBuilder_ != null) { + return fldBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(fld_); + } + } + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField.Builder addFldBuilder() { + return getFldFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField.getDefaultInstance()); + } + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField.Builder addFldBuilder( + int index) { + return getFldFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField.getDefaultInstance()); + } + /** + * repeated .Mysqlx.Datatypes.Object.ObjectField fld = 1; + */ + public java.util.List + getFldBuilderList() { + return getFldFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField, com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectFieldOrBuilder> + getFldFieldBuilder() { + if (fldBuilder_ == null) { + fldBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField, com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectField.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.ObjectFieldOrBuilder>( + fld_, + ((bitField0_ & 0x00000001) != 0), + getParentForChildren(), + isClean()); + fld_ = null; + } + return fldBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Datatypes.Object) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Datatypes.Object) + private static final com.mysql.cj.x.protobuf.MysqlxDatatypes.Object DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxDatatypes.Object(); + } + + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Object getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Object parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Object(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Object getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ArrayOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Datatypes.Array) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + java.util.List + getValueList(); + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any getValue(int index); + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + int getValueCount(); + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + java.util.List + getValueOrBuilderList(); + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder getValueOrBuilder( + int index); + } + /** + * 
+   **
+   *An Array
+   *
+ * + * Protobuf type {@code Mysqlx.Datatypes.Array} + */ + public static final class Array extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Datatypes.Array) + ArrayOrBuilder { + private static final long serialVersionUID = 0L; + // Use Array.newBuilder() to construct. + private Array(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Array() { + value_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Array(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Array( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + if (!((mutable_bitField0_ & 0x00000001) != 0)) { + value_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + value_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.PARSER, extensionRegistry)); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000001) != 0)) { + value_ = java.util.Collections.unmodifiableList(value_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Array_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Array_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Array.class, com.mysql.cj.x.protobuf.MysqlxDatatypes.Array.Builder.class); + } + + public static final int VALUE_FIELD_NUMBER = 1; + private java.util.List value_; + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public java.util.List getValueList() { + return value_; + } + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public java.util.List + getValueOrBuilderList() { + return value_; + } + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public int getValueCount() { + return value_.size(); + } + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any getValue(int index) { + return value_.get(index); + } + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder getValueOrBuilder( + int index) { + return value_.get(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + for (int i = 0; i < getValueCount(); i++) { + if (!getValue(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < value_.size(); i++) { + output.writeMessage(1, value_.get(i)); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < value_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, value_.get(i)); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxDatatypes.Array)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxDatatypes.Array other = (com.mysql.cj.x.protobuf.MysqlxDatatypes.Array) obj; + + if (!getValueList() + .equals(other.getValueList())) return false; + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getValueCount() > 0) { + hash = (37 * hash) + VALUE_FIELD_NUMBER; + hash = (53 * hash) + getValueList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Array parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Array parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Array parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Array parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Array parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Array parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Array parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Array parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Array parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Array parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Array parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Array parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxDatatypes.Array prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *An Array
+     *
+ * + * Protobuf type {@code Mysqlx.Datatypes.Array} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Datatypes.Array) + com.mysql.cj.x.protobuf.MysqlxDatatypes.ArrayOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Array_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Array_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Array.class, com.mysql.cj.x.protobuf.MysqlxDatatypes.Array.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxDatatypes.Array.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getValueFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + if (valueBuilder_ == null) { + value_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + } else { + valueBuilder_.clear(); + } + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Array_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Array getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.Array.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Array build() { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Array result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Array buildPartial() { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Array result = new com.mysql.cj.x.protobuf.MysqlxDatatypes.Array(this); + int from_bitField0_ = bitField0_; + if (valueBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0)) { + value_ = java.util.Collections.unmodifiableList(value_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.value_ = value_; + } else { + result.value_ = valueBuilder_.build(); + } + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxDatatypes.Array) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxDatatypes.Array)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxDatatypes.Array other) { + if (other == com.mysql.cj.x.protobuf.MysqlxDatatypes.Array.getDefaultInstance()) return this; + if (valueBuilder_ == null) { + if (!other.value_.isEmpty()) { + if (value_.isEmpty()) { + value_ = other.value_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureValueIsMutable(); + value_.addAll(other.value_); + } + onChanged(); + } + } else { + if (!other.value_.isEmpty()) { + if (valueBuilder_.isEmpty()) { + valueBuilder_.dispose(); + valueBuilder_ = null; + value_ = other.value_; + bitField0_ = (bitField0_ & ~0x00000001); + valueBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getValueFieldBuilder() : null; + } else { + valueBuilder_.addAllMessages(other.value_); + } + } + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + for (int i = 0; i < getValueCount(); i++) { + if (!getValue(i).isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Array parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxDatatypes.Array) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List value_ = + java.util.Collections.emptyList(); + private void ensureValueIsMutable() { + if (!((bitField0_ & 0x00000001) != 0)) { + value_ = new java.util.ArrayList(value_); + bitField0_ |= 0x00000001; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder> valueBuilder_; + + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public java.util.List getValueList() { + if (valueBuilder_ == null) { + return java.util.Collections.unmodifiableList(value_); + } else { + return valueBuilder_.getMessageList(); + } + } + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public int getValueCount() { + if (valueBuilder_ == null) { + return value_.size(); + } else { + return valueBuilder_.getCount(); + } + } + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any getValue(int index) { + if (valueBuilder_ == null) { + return value_.get(index); + } else { + return valueBuilder_.getMessage(index); + } + } + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public Builder setValue( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any value) { + if (valueBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureValueIsMutable(); + value_.set(index, value); + onChanged(); + } else { + valueBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public Builder setValue( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder builderForValue) { + if (valueBuilder_ == null) { + ensureValueIsMutable(); + value_.set(index, builderForValue.build()); + onChanged(); + } else { + valueBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public Builder addValue(com.mysql.cj.x.protobuf.MysqlxDatatypes.Any value) { + if (valueBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureValueIsMutable(); + value_.add(value); + onChanged(); + } else { + valueBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public Builder addValue( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any value) { + if (valueBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureValueIsMutable(); + value_.add(index, value); + onChanged(); + } else { + valueBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public Builder addValue( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder builderForValue) { + if (valueBuilder_ == null) { + ensureValueIsMutable(); + value_.add(builderForValue.build()); + onChanged(); + } else { + valueBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public Builder addValue( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder builderForValue) { + if (valueBuilder_ == null) { + ensureValueIsMutable(); + value_.add(index, builderForValue.build()); + onChanged(); + } else { + valueBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public Builder addAllValue( + java.lang.Iterable values) { + if (valueBuilder_ == null) { + ensureValueIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, value_); + onChanged(); + } else { + valueBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public Builder clearValue() { + if (valueBuilder_ == null) { + value_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + } else { + valueBuilder_.clear(); + } + return this; + } + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public Builder removeValue(int index) { + if (valueBuilder_ == null) { + ensureValueIsMutable(); + value_.remove(index); + onChanged(); + } else { + valueBuilder_.remove(index); + } + return this; + } + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder getValueBuilder( + int index) { + return getValueFieldBuilder().getBuilder(index); + } + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder getValueOrBuilder( + int index) { + if (valueBuilder_ == null) { + return value_.get(index); } else { + return valueBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public java.util.List + getValueOrBuilderList() { + if (valueBuilder_ != null) { + return valueBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(value_); + } + } + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder addValueBuilder() { + return getValueFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.getDefaultInstance()); + } + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder addValueBuilder( + int index) { + return getValueFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.getDefaultInstance()); + } + /** + * repeated .Mysqlx.Datatypes.Any value = 1; + */ + public java.util.List + getValueBuilderList() { + return getValueFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder> + getValueFieldBuilder() { + if (valueBuilder_ == null) { + valueBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder>( + value_, + ((bitField0_ & 0x00000001) != 0), + getParentForChildren(), + isClean()); + value_ = null; + } + return valueBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Datatypes.Array) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Datatypes.Array) + private static final com.mysql.cj.x.protobuf.MysqlxDatatypes.Array DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxDatatypes.Array(); + } + + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Array getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Array parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Array(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Array getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface AnyOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Datatypes.Any) + com.google.protobuf.MessageOrBuilder { + + /** + * required .Mysqlx.Datatypes.Any.Type type = 1; + * @return Whether the type field is set. + */ + boolean hasType(); + /** + * required .Mysqlx.Datatypes.Any.Type type = 1; + * @return The type. + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Type getType(); + + /** + * optional .Mysqlx.Datatypes.Scalar scalar = 2; + * @return Whether the scalar field is set. + */ + boolean hasScalar(); + /** + * optional .Mysqlx.Datatypes.Scalar scalar = 2; + * @return The scalar. + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getScalar(); + /** + * optional .Mysqlx.Datatypes.Scalar scalar = 2; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getScalarOrBuilder(); + + /** + * optional .Mysqlx.Datatypes.Object obj = 3; + * @return Whether the obj field is set. + */ + boolean hasObj(); + /** + * optional .Mysqlx.Datatypes.Object obj = 3; + * @return The obj. + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object getObj(); + /** + * optional .Mysqlx.Datatypes.Object obj = 3; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.ObjectOrBuilder getObjOrBuilder(); + + /** + * optional .Mysqlx.Datatypes.Array array = 4; + * @return Whether the array field is set. + */ + boolean hasArray(); + /** + * optional .Mysqlx.Datatypes.Array array = 4; + * @return The array. + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Array getArray(); + /** + * optional .Mysqlx.Datatypes.Array array = 4; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.ArrayOrBuilder getArrayOrBuilder(); + } + /** + * 
+   **
+   *A helper to allow all field types
+   *
+ * + * Protobuf type {@code Mysqlx.Datatypes.Any} + */ + public static final class Any extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Datatypes.Any) + AnyOrBuilder { + private static final long serialVersionUID = 0L; + // Use Any.newBuilder() to construct. + private Any(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Any() { + type_ = 1; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Any(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Any( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Type value = com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Type.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(1, rawValue); + } else { + bitField0_ |= 0x00000001; + type_ = rawValue; + } + break; + } + case 18: { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) != 0)) { + subBuilder = scalar_.toBuilder(); + } + scalar_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(scalar_); + scalar_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) != 0)) { + subBuilder = obj_.toBuilder(); + } + obj_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(obj_); + obj_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 34: { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Array.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) != 0)) { + subBuilder = array_.toBuilder(); + } + array_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxDatatypes.Array.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(array_); + array_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Any_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Any_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.class, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder.class); + } + + /** + * Protobuf enum {@code Mysqlx.Datatypes.Any.Type} + */ + public enum Type + implements com.google.protobuf.ProtocolMessageEnum { + /** + * SCALAR = 1; + */ + SCALAR(1), + /** + * OBJECT = 2; + */ + OBJECT(2), + /** + * ARRAY = 3; + */ + ARRAY(3), + ; + + /** + * SCALAR = 1; + */ + public static final int SCALAR_VALUE = 1; + /** + * OBJECT = 2; + */ + public static final int OBJECT_VALUE = 2; + /** + * ARRAY = 3; + */ + public static final int ARRAY_VALUE = 3; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static Type valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static Type forNumber(int value) { + switch (value) { + case 1: return SCALAR; + case 2: return OBJECT; + case 3: return ARRAY; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + Type> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Type findValueByNumber(int number) { + return Type.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.getDescriptor().getEnumTypes().get(0); + } + + private static final Type[] VALUES = values(); + + public static Type valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private Type(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Datatypes.Any.Type) + } + + private int bitField0_; + public static final int TYPE_FIELD_NUMBER = 1; + private int type_; + /** + * required .Mysqlx.Datatypes.Any.Type type = 1; + * @return Whether the type field is set. + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required .Mysqlx.Datatypes.Any.Type type = 1; + * @return The type. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Type getType() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Type result = com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Type.valueOf(type_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Type.SCALAR : result; + } + + public static final int SCALAR_FIELD_NUMBER = 2; + private com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar scalar_; + /** + * optional .Mysqlx.Datatypes.Scalar scalar = 2; + * @return Whether the scalar field is set. + */ + public boolean hasScalar() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional .Mysqlx.Datatypes.Scalar scalar = 2; + * @return The scalar. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getScalar() { + return scalar_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance() : scalar_; + } + /** + * optional .Mysqlx.Datatypes.Scalar scalar = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getScalarOrBuilder() { + return scalar_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance() : scalar_; + } + + public static final int OBJ_FIELD_NUMBER = 3; + private com.mysql.cj.x.protobuf.MysqlxDatatypes.Object obj_; + /** + * optional .Mysqlx.Datatypes.Object obj = 3; + * @return Whether the obj field is set. + */ + public boolean hasObj() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * optional .Mysqlx.Datatypes.Object obj = 3; + * @return The obj. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Object getObj() { + return obj_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.getDefaultInstance() : obj_; + } + /** + * optional .Mysqlx.Datatypes.Object obj = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.ObjectOrBuilder getObjOrBuilder() { + return obj_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.getDefaultInstance() : obj_; + } + + public static final int ARRAY_FIELD_NUMBER = 4; + private com.mysql.cj.x.protobuf.MysqlxDatatypes.Array array_; + /** + * optional .Mysqlx.Datatypes.Array array = 4; + * @return Whether the array field is set. + */ + public boolean hasArray() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * optional .Mysqlx.Datatypes.Array array = 4; + * @return The array. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Array getArray() { + return array_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Array.getDefaultInstance() : array_; + } + /** + * optional .Mysqlx.Datatypes.Array array = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.ArrayOrBuilder getArrayOrBuilder() { + return array_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Array.getDefaultInstance() : array_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasType()) { + memoizedIsInitialized = 0; + return false; + } + if (hasScalar()) { + if (!getScalar().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasObj()) { + if (!getObj().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasArray()) { + if (!getArray().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeEnum(1, type_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeMessage(2, getScalar()); + } + if (((bitField0_ & 0x00000004) != 0)) { + output.writeMessage(3, getObj()); + } + if (((bitField0_ & 0x00000008) != 0)) { + output.writeMessage(4, getArray()); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(1, type_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, getScalar()); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, getObj()); + } + if (((bitField0_ & 0x00000008) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, getArray()); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxDatatypes.Any)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any other = (com.mysql.cj.x.protobuf.MysqlxDatatypes.Any) obj; + + if (hasType() != other.hasType()) return false; + if (hasType()) { + if (type_ != other.type_) return false; + } + if (hasScalar() != other.hasScalar()) return false; + if (hasScalar()) { + if (!getScalar() + .equals(other.getScalar())) return false; + } + if (hasObj() != other.hasObj()) return false; + if (hasObj()) { + if (!getObj() + .equals(other.getObj())) return false; + } + if (hasArray() != other.hasArray()) return false; + if (hasArray()) { + if (!getArray() + .equals(other.getArray())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasType()) { + hash = (37 * hash) + TYPE_FIELD_NUMBER; + hash = (53 * hash) + type_; + } + if (hasScalar()) { + hash = (37 * hash) + SCALAR_FIELD_NUMBER; + hash = (53 * hash) + getScalar().hashCode(); + } + if (hasObj()) { + hash = (37 * hash) + OBJ_FIELD_NUMBER; + hash = (53 * hash) + getObj().hashCode(); + } + if (hasArray()) { + hash = (37 * hash) + ARRAY_FIELD_NUMBER; + hash = (53 * hash) + getArray().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Any parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Any parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Any parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Any parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Any parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Any parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Any parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Any parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Any parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Any parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Any parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Any parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxDatatypes.Any prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *A helper to allow all field types
+     *
+ * + * Protobuf type {@code Mysqlx.Datatypes.Any} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Datatypes.Any) + com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Any_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Any_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.class, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getScalarFieldBuilder(); + getObjFieldBuilder(); + getArrayFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + type_ = 1; + bitField0_ = (bitField0_ & ~0x00000001); + if (scalarBuilder_ == null) { + scalar_ = null; + } else { + scalarBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + if (objBuilder_ == null) { + obj_ = null; + } else { + objBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + if (arrayBuilder_ == null) { + array_ = null; + } else { + arrayBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.internal_static_Mysqlx_Datatypes_Any_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any build() { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any buildPartial() { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any result = new com.mysql.cj.x.protobuf.MysqlxDatatypes.Any(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.type_ = type_; + if (((from_bitField0_ & 0x00000002) != 0)) { + if (scalarBuilder_ == null) { + result.scalar_ = scalar_; + } else { + result.scalar_ = scalarBuilder_.build(); + } + to_bitField0_ |= 0x00000002; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + if (objBuilder_ == null) { + result.obj_ = obj_; + } else { + result.obj_ = objBuilder_.build(); + } + to_bitField0_ |= 0x00000004; + } + if (((from_bitField0_ & 0x00000008) != 0)) { + if (arrayBuilder_ == null) { + result.array_ = array_; + } else { + result.array_ = arrayBuilder_.build(); + } + to_bitField0_ |= 0x00000008; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxDatatypes.Any) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxDatatypes.Any)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxDatatypes.Any other) { + if (other == com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.getDefaultInstance()) return this; + if (other.hasType()) { + setType(other.getType()); + } + if (other.hasScalar()) { + mergeScalar(other.getScalar()); + } + if (other.hasObj()) { + mergeObj(other.getObj()); + } + if (other.hasArray()) { + mergeArray(other.getArray()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasType()) { + return false; + } + if (hasScalar()) { + if (!getScalar().isInitialized()) { + return false; + } + } + if (hasObj()) { + if (!getObj().isInitialized()) { + return false; + } + } + if (hasArray()) { + if (!getArray().isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxDatatypes.Any) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int type_ = 1; + /** + * required .Mysqlx.Datatypes.Any.Type type = 1; + * @return Whether the type field is set. + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required .Mysqlx.Datatypes.Any.Type type = 1; + * @return The type. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Type getType() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Type result = com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Type.valueOf(type_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Type.SCALAR : result; + } + /** + * required .Mysqlx.Datatypes.Any.Type type = 1; + * @param value The type to set. + * @return This builder for chaining. + */ + public Builder setType(com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Type value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + type_ = value.getNumber(); + onChanged(); + return this; + } + /** + * required .Mysqlx.Datatypes.Any.Type type = 1; + * @return This builder for chaining. + */ + public Builder clearType() { + bitField0_ = (bitField0_ & ~0x00000001); + type_ = 1; + onChanged(); + return this; + } + + private com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar scalar_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder> scalarBuilder_; + /** + * optional .Mysqlx.Datatypes.Scalar scalar = 2; + * @return Whether the scalar field is set. + */ + public boolean hasScalar() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional .Mysqlx.Datatypes.Scalar scalar = 2; + * @return The scalar. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getScalar() { + if (scalarBuilder_ == null) { + return scalar_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance() : scalar_; + } else { + return scalarBuilder_.getMessage(); + } + } + /** + * optional .Mysqlx.Datatypes.Scalar scalar = 2; + */ + public Builder setScalar(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value) { + if (scalarBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + scalar_ = value; + onChanged(); + } else { + scalarBuilder_.setMessage(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .Mysqlx.Datatypes.Scalar scalar = 2; + */ + public Builder setScalar( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder builderForValue) { + if (scalarBuilder_ == null) { + scalar_ = builderForValue.build(); + onChanged(); + } else { + scalarBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .Mysqlx.Datatypes.Scalar scalar = 2; + */ + public Builder mergeScalar(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value) { + if (scalarBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0) && + scalar_ != null && + scalar_ != com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance()) { + scalar_ = + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.newBuilder(scalar_).mergeFrom(value).buildPartial(); + } else { + scalar_ = value; + } + onChanged(); + } else { + scalarBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .Mysqlx.Datatypes.Scalar scalar = 2; + */ + public Builder clearScalar() { + if (scalarBuilder_ == null) { + scalar_ = null; + onChanged(); + } else { + scalarBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + /** + * optional .Mysqlx.Datatypes.Scalar scalar = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder getScalarBuilder() { + bitField0_ |= 0x00000002; + onChanged(); + return getScalarFieldBuilder().getBuilder(); + } + /** + * optional .Mysqlx.Datatypes.Scalar scalar = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getScalarOrBuilder() { + if (scalarBuilder_ != null) { + return scalarBuilder_.getMessageOrBuilder(); + } else { + return scalar_ == null ? + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance() : scalar_; + } + } + /** + * optional .Mysqlx.Datatypes.Scalar scalar = 2; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder> + getScalarFieldBuilder() { + if (scalarBuilder_ == null) { + scalarBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder>( + getScalar(), + getParentForChildren(), + isClean()); + scalar_ = null; + } + return scalarBuilder_; + } + + private com.mysql.cj.x.protobuf.MysqlxDatatypes.Object obj_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object, com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ObjectOrBuilder> objBuilder_; + /** + * optional .Mysqlx.Datatypes.Object obj = 3; + * @return Whether the obj field is set. + */ + public boolean hasObj() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * optional .Mysqlx.Datatypes.Object obj = 3; + * @return The obj. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Object getObj() { + if (objBuilder_ == null) { + return obj_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.getDefaultInstance() : obj_; + } else { + return objBuilder_.getMessage(); + } + } + /** + * optional .Mysqlx.Datatypes.Object obj = 3; + */ + public Builder setObj(com.mysql.cj.x.protobuf.MysqlxDatatypes.Object value) { + if (objBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + obj_ = value; + onChanged(); + } else { + objBuilder_.setMessage(value); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .Mysqlx.Datatypes.Object obj = 3; + */ + public Builder setObj( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.Builder builderForValue) { + if (objBuilder_ == null) { + obj_ = builderForValue.build(); + onChanged(); + } else { + objBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .Mysqlx.Datatypes.Object obj = 3; + */ + public Builder mergeObj(com.mysql.cj.x.protobuf.MysqlxDatatypes.Object value) { + if (objBuilder_ == null) { + if (((bitField0_ & 0x00000004) != 0) && + obj_ != null && + obj_ != com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.getDefaultInstance()) { + obj_ = + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.newBuilder(obj_).mergeFrom(value).buildPartial(); + } else { + obj_ = value; + } + onChanged(); + } else { + objBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .Mysqlx.Datatypes.Object obj = 3; + */ + public Builder clearObj() { + if (objBuilder_ == null) { + obj_ = null; + onChanged(); + } else { + objBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + /** + * optional .Mysqlx.Datatypes.Object obj = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.Builder getObjBuilder() { + bitField0_ |= 0x00000004; + onChanged(); + return getObjFieldBuilder().getBuilder(); + } + /** + * optional .Mysqlx.Datatypes.Object obj = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.ObjectOrBuilder getObjOrBuilder() { + if (objBuilder_ != null) { + return objBuilder_.getMessageOrBuilder(); + } else { + return obj_ == null ? + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.getDefaultInstance() : obj_; + } + } + /** + * optional .Mysqlx.Datatypes.Object obj = 3; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object, com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ObjectOrBuilder> + getObjFieldBuilder() { + if (objBuilder_ == null) { + objBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Object, com.mysql.cj.x.protobuf.MysqlxDatatypes.Object.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ObjectOrBuilder>( + getObj(), + getParentForChildren(), + isClean()); + obj_ = null; + } + return objBuilder_; + } + + private com.mysql.cj.x.protobuf.MysqlxDatatypes.Array array_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Array, com.mysql.cj.x.protobuf.MysqlxDatatypes.Array.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ArrayOrBuilder> arrayBuilder_; + /** + * optional .Mysqlx.Datatypes.Array array = 4; + * @return Whether the array field is set. + */ + public boolean hasArray() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * optional .Mysqlx.Datatypes.Array array = 4; + * @return The array. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Array getArray() { + if (arrayBuilder_ == null) { + return array_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Array.getDefaultInstance() : array_; + } else { + return arrayBuilder_.getMessage(); + } + } + /** + * optional .Mysqlx.Datatypes.Array array = 4; + */ + public Builder setArray(com.mysql.cj.x.protobuf.MysqlxDatatypes.Array value) { + if (arrayBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + array_ = value; + onChanged(); + } else { + arrayBuilder_.setMessage(value); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .Mysqlx.Datatypes.Array array = 4; + */ + public Builder setArray( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Array.Builder builderForValue) { + if (arrayBuilder_ == null) { + array_ = builderForValue.build(); + onChanged(); + } else { + arrayBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .Mysqlx.Datatypes.Array array = 4; + */ + public Builder mergeArray(com.mysql.cj.x.protobuf.MysqlxDatatypes.Array value) { + if (arrayBuilder_ == null) { + if (((bitField0_ & 0x00000008) != 0) && + array_ != null && + array_ != com.mysql.cj.x.protobuf.MysqlxDatatypes.Array.getDefaultInstance()) { + array_ = + com.mysql.cj.x.protobuf.MysqlxDatatypes.Array.newBuilder(array_).mergeFrom(value).buildPartial(); + } else { + array_ = value; + } + onChanged(); + } else { + arrayBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .Mysqlx.Datatypes.Array array = 4; + */ + public Builder clearArray() { + if (arrayBuilder_ == null) { + array_ = null; + onChanged(); + } else { + arrayBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + /** + * optional .Mysqlx.Datatypes.Array array = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Array.Builder getArrayBuilder() { + bitField0_ |= 0x00000008; + onChanged(); + return getArrayFieldBuilder().getBuilder(); + } + /** + * optional .Mysqlx.Datatypes.Array array = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.ArrayOrBuilder getArrayOrBuilder() { + if (arrayBuilder_ != null) { + return arrayBuilder_.getMessageOrBuilder(); + } else { + return array_ == null ? + com.mysql.cj.x.protobuf.MysqlxDatatypes.Array.getDefaultInstance() : array_; + } + } + /** + * optional .Mysqlx.Datatypes.Array array = 4; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Array, com.mysql.cj.x.protobuf.MysqlxDatatypes.Array.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ArrayOrBuilder> + getArrayFieldBuilder() { + if (arrayBuilder_ == null) { + arrayBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Array, com.mysql.cj.x.protobuf.MysqlxDatatypes.Array.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ArrayOrBuilder>( + getArray(), + getParentForChildren(), + isClean()); + array_ = null; + } + return arrayBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Datatypes.Any) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Datatypes.Any) + private static final com.mysql.cj.x.protobuf.MysqlxDatatypes.Any DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxDatatypes.Any(); + } + + public static com.mysql.cj.x.protobuf.MysqlxDatatypes.Any getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Any parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Any(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Datatypes_Scalar_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Datatypes_Scalar_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Datatypes_Scalar_String_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Datatypes_Scalar_String_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Datatypes_Scalar_Octets_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Datatypes_Scalar_Octets_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Datatypes_Object_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Datatypes_Object_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Datatypes_Object_ObjectField_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Datatypes_Object_ObjectField_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Datatypes_Array_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Datatypes_Array_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Datatypes_Any_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Datatypes_Any_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\026mysqlx_datatypes.proto\022\020Mysqlx.Datatyp" + + "es\"\306\003\n\006Scalar\022+\n\004type\030\001 \002(\0162\035.Mysqlx.Dat" + + "atypes.Scalar.Type\022\024\n\014v_signed_int\030\002 \001(\022" + + "\022\026\n\016v_unsigned_int\030\003 \001(\004\0221\n\010v_octets\030\005 \001" + + "(\0132\037.Mysqlx.Datatypes.Scalar.Octets\022\020\n\010v" + + "_double\030\006 \001(\001\022\017\n\007v_float\030\007 \001(\002\022\016\n\006v_bool" + + "\030\010 \001(\010\0221\n\010v_string\030\t \001(\0132\037.Mysqlx.Dataty" + + "pes.Scalar.String\032*\n\006String\022\r\n\005value\030\001 \002" + + "(\014\022\021\n\tcollation\030\002 \001(\004\032-\n\006Octets\022\r\n\005value" + + "\030\001 \002(\014\022\024\n\014content_type\030\002 \001(\r\"m\n\004Type\022\n\n\006" + + "V_SINT\020\001\022\n\n\006V_UINT\020\002\022\n\n\006V_NULL\020\003\022\014\n\010V_OC" + + "TETS\020\004\022\014\n\010V_DOUBLE\020\005\022\013\n\007V_FLOAT\020\006\022\n\n\006V_B" + + "OOL\020\007\022\014\n\010V_STRING\020\010\"}\n\006Object\0221\n\003fld\030\001 \003" + + "(\0132$.Mysqlx.Datatypes.Object.ObjectField" + + "\032@\n\013ObjectField\022\013\n\003key\030\001 \002(\t\022$\n\005value\030\002 " + + "\002(\0132\025.Mysqlx.Datatypes.Any\"-\n\005Array\022$\n\005v" + + "alue\030\001 \003(\0132\025.Mysqlx.Datatypes.Any\"\323\001\n\003An" + + "y\022(\n\004type\030\001 \002(\0162\032.Mysqlx.Datatypes.Any.T" + + "ype\022(\n\006scalar\030\002 \001(\0132\030.Mysqlx.Datatypes.S" + + "calar\022%\n\003obj\030\003 \001(\0132\030.Mysqlx.Datatypes.Ob" + + "ject\022&\n\005array\030\004 \001(\0132\027.Mysqlx.Datatypes.A" + + "rray\")\n\004Type\022\n\n\006SCALAR\020\001\022\n\n\006OBJECT\020\002\022\t\n\005" + + "ARRAY\020\003B\031\n\027com.mysql.cj.x.protobuf" + }; + descriptor = com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + }); + internal_static_Mysqlx_Datatypes_Scalar_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_Mysqlx_Datatypes_Scalar_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Datatypes_Scalar_descriptor, + new java.lang.String[] { "Type", "VSignedInt", "VUnsignedInt", "VOctets", "VDouble", "VFloat", "VBool", "VString", }); + internal_static_Mysqlx_Datatypes_Scalar_String_descriptor = + internal_static_Mysqlx_Datatypes_Scalar_descriptor.getNestedTypes().get(0); + internal_static_Mysqlx_Datatypes_Scalar_String_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Datatypes_Scalar_String_descriptor, + new java.lang.String[] { "Value", "Collation", }); + internal_static_Mysqlx_Datatypes_Scalar_Octets_descriptor = + internal_static_Mysqlx_Datatypes_Scalar_descriptor.getNestedTypes().get(1); + internal_static_Mysqlx_Datatypes_Scalar_Octets_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Datatypes_Scalar_Octets_descriptor, + new java.lang.String[] { "Value", "ContentType", }); + internal_static_Mysqlx_Datatypes_Object_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_Mysqlx_Datatypes_Object_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Datatypes_Object_descriptor, + new java.lang.String[] { "Fld", }); + internal_static_Mysqlx_Datatypes_Object_ObjectField_descriptor = + internal_static_Mysqlx_Datatypes_Object_descriptor.getNestedTypes().get(0); + internal_static_Mysqlx_Datatypes_Object_ObjectField_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Datatypes_Object_ObjectField_descriptor, + new java.lang.String[] { "Key", "Value", }); + internal_static_Mysqlx_Datatypes_Array_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_Mysqlx_Datatypes_Array_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Datatypes_Array_descriptor, + new java.lang.String[] { "Value", }); + internal_static_Mysqlx_Datatypes_Any_descriptor = + getDescriptor().getMessageTypes().get(3); + internal_static_Mysqlx_Datatypes_Any_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Datatypes_Any_descriptor, + new java.lang.String[] { "Type", "Scalar", "Obj", "Array", }); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxExpect.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxExpect.java new file mode 100644 index 0000000..3e7d37d --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxExpect.java @@ -0,0 +1,2568 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.x.protobuf; + +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: mysqlx_expect.proto + +public final class MysqlxExpect { + private MysqlxExpect() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + public interface OpenOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Expect.Open) + com.google.protobuf.MessageOrBuilder { + + /** + * optional .Mysqlx.Expect.Open.CtxOperation op = 1 [default = EXPECT_CTX_COPY_PREV]; + * @return Whether the op field is set. + */ + boolean hasOp(); + /** + * optional .Mysqlx.Expect.Open.CtxOperation op = 1 [default = EXPECT_CTX_COPY_PREV]; + * @return The op. + */ + com.mysql.cj.x.protobuf.MysqlxExpect.Open.CtxOperation getOp(); + + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + java.util.List + getCondList(); + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition getCond(int index); + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + int getCondCount(); + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + java.util.List + getCondOrBuilderList(); + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + com.mysql.cj.x.protobuf.MysqlxExpect.Open.ConditionOrBuilder getCondOrBuilder( + int index); + } + /** + * 
+   **
+   *Open an Expect block and set/unset the conditions that have to
+   *be fulfilled.
+   *If any of the conditions fail, all enclosed messages will fail
+   *with a ``Mysqlx::Error`` message.
+   *@returns @ref Mysqlx::Ok on success, @ref Mysqlx::Error on error
+   *
+ * + * Protobuf type {@code Mysqlx.Expect.Open} + */ + public static final class Open extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Expect.Open) + OpenOrBuilder { + private static final long serialVersionUID = 0L; + // Use Open.newBuilder() to construct. + private Open(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Open() { + op_ = 0; + cond_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Open(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Open( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxExpect.Open.CtxOperation value = com.mysql.cj.x.protobuf.MysqlxExpect.Open.CtxOperation.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(1, rawValue); + } else { + bitField0_ |= 0x00000001; + op_ = rawValue; + } + break; + } + case 18: { + if (!((mutable_bitField0_ & 0x00000002) != 0)) { + cond_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000002; + } + cond_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.PARSER, extensionRegistry)); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000002) != 0)) { + cond_ = java.util.Collections.unmodifiableList(cond_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpect.internal_static_Mysqlx_Expect_Open_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpect.internal_static_Mysqlx_Expect_Open_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpect.Open.class, com.mysql.cj.x.protobuf.MysqlxExpect.Open.Builder.class); + } + + /** + * Protobuf enum {@code Mysqlx.Expect.Open.CtxOperation} + */ + public enum CtxOperation + implements com.google.protobuf.ProtocolMessageEnum { + /** + * 
+       ** copy the operations from the parent Expect-block 
+       *
+ * + * EXPECT_CTX_COPY_PREV = 0; + */ + EXPECT_CTX_COPY_PREV(0), + /** + * 
+       ** start with a empty set of operations 
+       *
+ * + * EXPECT_CTX_EMPTY = 1; + */ + EXPECT_CTX_EMPTY(1), + ; + + /** + * 
+       ** copy the operations from the parent Expect-block 
+       *
+ * + * EXPECT_CTX_COPY_PREV = 0; + */ + public static final int EXPECT_CTX_COPY_PREV_VALUE = 0; + /** + * 
+       ** start with a empty set of operations 
+       *
+ * + * EXPECT_CTX_EMPTY = 1; + */ + public static final int EXPECT_CTX_EMPTY_VALUE = 1; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static CtxOperation valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static CtxOperation forNumber(int value) { + switch (value) { + case 0: return EXPECT_CTX_COPY_PREV; + case 1: return EXPECT_CTX_EMPTY; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + CtxOperation> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public CtxOperation findValueByNumber(int number) { + return CtxOperation.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpect.Open.getDescriptor().getEnumTypes().get(0); + } + + private static final CtxOperation[] VALUES = values(); + + public static CtxOperation valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private CtxOperation(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Expect.Open.CtxOperation) + } + + public interface ConditionOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Expect.Open.Condition) + com.google.protobuf.MessageOrBuilder { + + /** + * required uint32 condition_key = 1; + * @return Whether the conditionKey field is set. + */ + boolean hasConditionKey(); + /** + * required uint32 condition_key = 1; + * @return The conditionKey. + */ + int getConditionKey(); + + /** + * optional bytes condition_value = 2; + * @return Whether the conditionValue field is set. + */ + boolean hasConditionValue(); + /** + * optional bytes condition_value = 2; + * @return The conditionValue. + */ + com.google.protobuf.ByteString getConditionValue(); + + /** + * optional .Mysqlx.Expect.Open.Condition.ConditionOperation op = 3 [default = EXPECT_OP_SET]; + * @return Whether the op field is set. + */ + boolean hasOp(); + /** + * optional .Mysqlx.Expect.Open.Condition.ConditionOperation op = 3 [default = EXPECT_OP_SET]; + * @return The op. + */ + com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.ConditionOperation getOp(); + } + /** + * Protobuf type {@code Mysqlx.Expect.Open.Condition} + */ + public static final class Condition extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Expect.Open.Condition) + ConditionOrBuilder { + private static final long serialVersionUID = 0L; + // Use Condition.newBuilder() to construct. + private Condition(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Condition() { + conditionValue_ = com.google.protobuf.ByteString.EMPTY; + op_ = 0; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Condition(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Condition( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + bitField0_ |= 0x00000001; + conditionKey_ = input.readUInt32(); + break; + } + case 18: { + bitField0_ |= 0x00000002; + conditionValue_ = input.readBytes(); + break; + } + case 24: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.ConditionOperation value = com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.ConditionOperation.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(3, rawValue); + } else { + bitField0_ |= 0x00000004; + op_ = rawValue; + } + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpect.internal_static_Mysqlx_Expect_Open_Condition_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpect.internal_static_Mysqlx_Expect_Open_Condition_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.class, com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.Builder.class); + } + + /** + * Protobuf enum {@code Mysqlx.Expect.Open.Condition.Key} + */ + public enum Key + implements com.google.protobuf.ProtocolMessageEnum { + /** + * 
+         ** Change error propagation behaviour 
+         *
+ * + * EXPECT_NO_ERROR = 1; + */ + EXPECT_NO_ERROR(1), + /** + * 
+         ** Check if X Protocol field exists 
+         *
+ * + * EXPECT_FIELD_EXIST = 2; + */ + EXPECT_FIELD_EXIST(2), + /** + * 
+         ** Check if X Protocol support document _id generation 
+         *
+ * + * EXPECT_DOCID_GENERATED = 3; + */ + EXPECT_DOCID_GENERATED(3), + ; + + /** + * 
+         ** Change error propagation behaviour 
+         *
+ * + * EXPECT_NO_ERROR = 1; + */ + public static final int EXPECT_NO_ERROR_VALUE = 1; + /** + * 
+         ** Check if X Protocol field exists 
+         *
+ * + * EXPECT_FIELD_EXIST = 2; + */ + public static final int EXPECT_FIELD_EXIST_VALUE = 2; + /** + * 
+         ** Check if X Protocol support document _id generation 
+         *
+ * + * EXPECT_DOCID_GENERATED = 3; + */ + public static final int EXPECT_DOCID_GENERATED_VALUE = 3; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static Key valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static Key forNumber(int value) { + switch (value) { + case 1: return EXPECT_NO_ERROR; + case 2: return EXPECT_FIELD_EXIST; + case 3: return EXPECT_DOCID_GENERATED; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + Key> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Key findValueByNumber(int number) { + return Key.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.getDescriptor().getEnumTypes().get(0); + } + + private static final Key[] VALUES = values(); + + public static Key valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private Key(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Expect.Open.Condition.Key) + } + + /** + * Protobuf enum {@code Mysqlx.Expect.Open.Condition.ConditionOperation} + */ + public enum ConditionOperation + implements com.google.protobuf.ProtocolMessageEnum { + /** + * 
+         ** set the condition; set, if not set; overwrite, if set 
+         *
+ * + * EXPECT_OP_SET = 0; + */ + EXPECT_OP_SET(0), + /** + * 
+         ** unset the condition 
+         *
+ * + * EXPECT_OP_UNSET = 1; + */ + EXPECT_OP_UNSET(1), + ; + + /** + * 
+         ** set the condition; set, if not set; overwrite, if set 
+         *
+ * + * EXPECT_OP_SET = 0; + */ + public static final int EXPECT_OP_SET_VALUE = 0; + /** + * 
+         ** unset the condition 
+         *
+ * + * EXPECT_OP_UNSET = 1; + */ + public static final int EXPECT_OP_UNSET_VALUE = 1; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static ConditionOperation valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static ConditionOperation forNumber(int value) { + switch (value) { + case 0: return EXPECT_OP_SET; + case 1: return EXPECT_OP_UNSET; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + ConditionOperation> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public ConditionOperation findValueByNumber(int number) { + return ConditionOperation.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.getDescriptor().getEnumTypes().get(1); + } + + private static final ConditionOperation[] VALUES = values(); + + public static ConditionOperation valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private ConditionOperation(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Expect.Open.Condition.ConditionOperation) + } + + private int bitField0_; + public static final int CONDITION_KEY_FIELD_NUMBER = 1; + private int conditionKey_; + /** + * required uint32 condition_key = 1; + * @return Whether the conditionKey field is set. + */ + public boolean hasConditionKey() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required uint32 condition_key = 1; + * @return The conditionKey. + */ + public int getConditionKey() { + return conditionKey_; + } + + public static final int CONDITION_VALUE_FIELD_NUMBER = 2; + private com.google.protobuf.ByteString conditionValue_; + /** + * optional bytes condition_value = 2; + * @return Whether the conditionValue field is set. + */ + public boolean hasConditionValue() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional bytes condition_value = 2; + * @return The conditionValue. + */ + public com.google.protobuf.ByteString getConditionValue() { + return conditionValue_; + } + + public static final int OP_FIELD_NUMBER = 3; + private int op_; + /** + * optional .Mysqlx.Expect.Open.Condition.ConditionOperation op = 3 [default = EXPECT_OP_SET]; + * @return Whether the op field is set. + */ + public boolean hasOp() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * optional .Mysqlx.Expect.Open.Condition.ConditionOperation op = 3 [default = EXPECT_OP_SET]; + * @return The op. + */ + public com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.ConditionOperation getOp() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.ConditionOperation result = com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.ConditionOperation.valueOf(op_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.ConditionOperation.EXPECT_OP_SET : result; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasConditionKey()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeUInt32(1, conditionKey_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeBytes(2, conditionValue_); + } + if (((bitField0_ & 0x00000004) != 0)) { + output.writeEnum(3, op_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(1, conditionKey_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, conditionValue_); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(3, op_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition other = (com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition) obj; + + if (hasConditionKey() != other.hasConditionKey()) return false; + if (hasConditionKey()) { + if (getConditionKey() + != other.getConditionKey()) return false; + } + if (hasConditionValue() != other.hasConditionValue()) return false; + if (hasConditionValue()) { + if (!getConditionValue() + .equals(other.getConditionValue())) return false; + } + if (hasOp() != other.hasOp()) return false; + if (hasOp()) { + if (op_ != other.op_) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasConditionKey()) { + hash = (37 * hash) + CONDITION_KEY_FIELD_NUMBER; + hash = (53 * hash) + getConditionKey(); + } + if (hasConditionValue()) { + hash = (37 * hash) + CONDITION_VALUE_FIELD_NUMBER; + hash = (53 * hash) + getConditionValue().hashCode(); + } + if (hasOp()) { + hash = (37 * hash) + OP_FIELD_NUMBER; + hash = (53 * hash) + op_; + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Mysqlx.Expect.Open.Condition} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Expect.Open.Condition) + com.mysql.cj.x.protobuf.MysqlxExpect.Open.ConditionOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpect.internal_static_Mysqlx_Expect_Open_Condition_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpect.internal_static_Mysqlx_Expect_Open_Condition_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.class, com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + conditionKey_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + conditionValue_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000002); + op_ = 0; + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxExpect.internal_static_Mysqlx_Expect_Open_Condition_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition build() { + com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition buildPartial() { + com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition result = new com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.conditionKey_ = conditionKey_; + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + to_bitField0_ |= 0x00000002; + } + result.conditionValue_ = conditionValue_; + if (((from_bitField0_ & 0x00000004) != 0)) { + to_bitField0_ |= 0x00000004; + } + result.op_ = op_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition other) { + if (other == com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.getDefaultInstance()) return this; + if (other.hasConditionKey()) { + setConditionKey(other.getConditionKey()); + } + if (other.hasConditionValue()) { + setConditionValue(other.getConditionValue()); + } + if (other.hasOp()) { + setOp(other.getOp()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasConditionKey()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int conditionKey_ ; + /** + * required uint32 condition_key = 1; + * @return Whether the conditionKey field is set. + */ + public boolean hasConditionKey() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required uint32 condition_key = 1; + * @return The conditionKey. + */ + public int getConditionKey() { + return conditionKey_; + } + /** + * required uint32 condition_key = 1; + * @param value The conditionKey to set. + * @return This builder for chaining. + */ + public Builder setConditionKey(int value) { + bitField0_ |= 0x00000001; + conditionKey_ = value; + onChanged(); + return this; + } + /** + * required uint32 condition_key = 1; + * @return This builder for chaining. + */ + public Builder clearConditionKey() { + bitField0_ = (bitField0_ & ~0x00000001); + conditionKey_ = 0; + onChanged(); + return this; + } + + private com.google.protobuf.ByteString conditionValue_ = com.google.protobuf.ByteString.EMPTY; + /** + * optional bytes condition_value = 2; + * @return Whether the conditionValue field is set. + */ + public boolean hasConditionValue() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional bytes condition_value = 2; + * @return The conditionValue. + */ + public com.google.protobuf.ByteString getConditionValue() { + return conditionValue_; + } + /** + * optional bytes condition_value = 2; + * @param value The conditionValue to set. + * @return This builder for chaining. + */ + public Builder setConditionValue(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + conditionValue_ = value; + onChanged(); + return this; + } + /** + * optional bytes condition_value = 2; + * @return This builder for chaining. + */ + public Builder clearConditionValue() { + bitField0_ = (bitField0_ & ~0x00000002); + conditionValue_ = getDefaultInstance().getConditionValue(); + onChanged(); + return this; + } + + private int op_ = 0; + /** + * optional .Mysqlx.Expect.Open.Condition.ConditionOperation op = 3 [default = EXPECT_OP_SET]; + * @return Whether the op field is set. + */ + public boolean hasOp() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * optional .Mysqlx.Expect.Open.Condition.ConditionOperation op = 3 [default = EXPECT_OP_SET]; + * @return The op. + */ + public com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.ConditionOperation getOp() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.ConditionOperation result = com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.ConditionOperation.valueOf(op_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.ConditionOperation.EXPECT_OP_SET : result; + } + /** + * optional .Mysqlx.Expect.Open.Condition.ConditionOperation op = 3 [default = EXPECT_OP_SET]; + * @param value The op to set. + * @return This builder for chaining. + */ + public Builder setOp(com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.ConditionOperation value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + op_ = value.getNumber(); + onChanged(); + return this; + } + /** + * optional .Mysqlx.Expect.Open.Condition.ConditionOperation op = 3 [default = EXPECT_OP_SET]; + * @return This builder for chaining. + */ + public Builder clearOp() { + bitField0_ = (bitField0_ & ~0x00000004); + op_ = 0; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Expect.Open.Condition) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Expect.Open.Condition) + private static final com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition(); + } + + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Condition parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Condition(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private int bitField0_; + public static final int OP_FIELD_NUMBER = 1; + private int op_; + /** + * optional .Mysqlx.Expect.Open.CtxOperation op = 1 [default = EXPECT_CTX_COPY_PREV]; + * @return Whether the op field is set. + */ + public boolean hasOp() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * optional .Mysqlx.Expect.Open.CtxOperation op = 1 [default = EXPECT_CTX_COPY_PREV]; + * @return The op. + */ + public com.mysql.cj.x.protobuf.MysqlxExpect.Open.CtxOperation getOp() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxExpect.Open.CtxOperation result = com.mysql.cj.x.protobuf.MysqlxExpect.Open.CtxOperation.valueOf(op_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxExpect.Open.CtxOperation.EXPECT_CTX_COPY_PREV : result; + } + + public static final int COND_FIELD_NUMBER = 2; + private java.util.List cond_; + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public java.util.List getCondList() { + return cond_; + } + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public java.util.List + getCondOrBuilderList() { + return cond_; + } + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public int getCondCount() { + return cond_.size(); + } + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition getCond(int index) { + return cond_.get(index); + } + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpect.Open.ConditionOrBuilder getCondOrBuilder( + int index) { + return cond_.get(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + for (int i = 0; i < getCondCount(); i++) { + if (!getCond(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeEnum(1, op_); + } + for (int i = 0; i < cond_.size(); i++) { + output.writeMessage(2, cond_.get(i)); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(1, op_); + } + for (int i = 0; i < cond_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, cond_.get(i)); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxExpect.Open)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxExpect.Open other = (com.mysql.cj.x.protobuf.MysqlxExpect.Open) obj; + + if (hasOp() != other.hasOp()) return false; + if (hasOp()) { + if (op_ != other.op_) return false; + } + if (!getCondList() + .equals(other.getCondList())) return false; + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasOp()) { + hash = (37 * hash) + OP_FIELD_NUMBER; + hash = (53 * hash) + op_; + } + if (getCondCount() > 0) { + hash = (37 * hash) + COND_FIELD_NUMBER; + hash = (53 * hash) + getCondList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxExpect.Open prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Open an Expect block and set/unset the conditions that have to
+     *be fulfilled.
+     *If any of the conditions fail, all enclosed messages will fail
+     *with a ``Mysqlx::Error`` message.
+     *@returns @ref Mysqlx::Ok on success, @ref Mysqlx::Error on error
+     *
+ * + * Protobuf type {@code Mysqlx.Expect.Open} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Expect.Open) + com.mysql.cj.x.protobuf.MysqlxExpect.OpenOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpect.internal_static_Mysqlx_Expect_Open_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpect.internal_static_Mysqlx_Expect_Open_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpect.Open.class, com.mysql.cj.x.protobuf.MysqlxExpect.Open.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxExpect.Open.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getCondFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + op_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + if (condBuilder_ == null) { + cond_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + } else { + condBuilder_.clear(); + } + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxExpect.internal_static_Mysqlx_Expect_Open_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpect.Open getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxExpect.Open.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpect.Open build() { + com.mysql.cj.x.protobuf.MysqlxExpect.Open result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpect.Open buildPartial() { + com.mysql.cj.x.protobuf.MysqlxExpect.Open result = new com.mysql.cj.x.protobuf.MysqlxExpect.Open(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.op_ = op_; + if (condBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0)) { + cond_ = java.util.Collections.unmodifiableList(cond_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.cond_ = cond_; + } else { + result.cond_ = condBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxExpect.Open) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxExpect.Open)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxExpect.Open other) { + if (other == com.mysql.cj.x.protobuf.MysqlxExpect.Open.getDefaultInstance()) return this; + if (other.hasOp()) { + setOp(other.getOp()); + } + if (condBuilder_ == null) { + if (!other.cond_.isEmpty()) { + if (cond_.isEmpty()) { + cond_ = other.cond_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureCondIsMutable(); + cond_.addAll(other.cond_); + } + onChanged(); + } + } else { + if (!other.cond_.isEmpty()) { + if (condBuilder_.isEmpty()) { + condBuilder_.dispose(); + condBuilder_ = null; + cond_ = other.cond_; + bitField0_ = (bitField0_ & ~0x00000002); + condBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getCondFieldBuilder() : null; + } else { + condBuilder_.addAllMessages(other.cond_); + } + } + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + for (int i = 0; i < getCondCount(); i++) { + if (!getCond(i).isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxExpect.Open parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxExpect.Open) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int op_ = 0; + /** + * optional .Mysqlx.Expect.Open.CtxOperation op = 1 [default = EXPECT_CTX_COPY_PREV]; + * @return Whether the op field is set. + */ + public boolean hasOp() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * optional .Mysqlx.Expect.Open.CtxOperation op = 1 [default = EXPECT_CTX_COPY_PREV]; + * @return The op. + */ + public com.mysql.cj.x.protobuf.MysqlxExpect.Open.CtxOperation getOp() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxExpect.Open.CtxOperation result = com.mysql.cj.x.protobuf.MysqlxExpect.Open.CtxOperation.valueOf(op_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxExpect.Open.CtxOperation.EXPECT_CTX_COPY_PREV : result; + } + /** + * optional .Mysqlx.Expect.Open.CtxOperation op = 1 [default = EXPECT_CTX_COPY_PREV]; + * @param value The op to set. + * @return This builder for chaining. + */ + public Builder setOp(com.mysql.cj.x.protobuf.MysqlxExpect.Open.CtxOperation value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + op_ = value.getNumber(); + onChanged(); + return this; + } + /** + * optional .Mysqlx.Expect.Open.CtxOperation op = 1 [default = EXPECT_CTX_COPY_PREV]; + * @return This builder for chaining. + */ + public Builder clearOp() { + bitField0_ = (bitField0_ & ~0x00000001); + op_ = 0; + onChanged(); + return this; + } + + private java.util.List cond_ = + java.util.Collections.emptyList(); + private void ensureCondIsMutable() { + if (!((bitField0_ & 0x00000002) != 0)) { + cond_ = new java.util.ArrayList(cond_); + bitField0_ |= 0x00000002; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition, com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.Builder, com.mysql.cj.x.protobuf.MysqlxExpect.Open.ConditionOrBuilder> condBuilder_; + + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public java.util.List getCondList() { + if (condBuilder_ == null) { + return java.util.Collections.unmodifiableList(cond_); + } else { + return condBuilder_.getMessageList(); + } + } + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public int getCondCount() { + if (condBuilder_ == null) { + return cond_.size(); + } else { + return condBuilder_.getCount(); + } + } + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition getCond(int index) { + if (condBuilder_ == null) { + return cond_.get(index); + } else { + return condBuilder_.getMessage(index); + } + } + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public Builder setCond( + int index, com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition value) { + if (condBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureCondIsMutable(); + cond_.set(index, value); + onChanged(); + } else { + condBuilder_.setMessage(index, value); + } + return this; + } + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public Builder setCond( + int index, com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.Builder builderForValue) { + if (condBuilder_ == null) { + ensureCondIsMutable(); + cond_.set(index, builderForValue.build()); + onChanged(); + } else { + condBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public Builder addCond(com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition value) { + if (condBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureCondIsMutable(); + cond_.add(value); + onChanged(); + } else { + condBuilder_.addMessage(value); + } + return this; + } + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public Builder addCond( + int index, com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition value) { + if (condBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureCondIsMutable(); + cond_.add(index, value); + onChanged(); + } else { + condBuilder_.addMessage(index, value); + } + return this; + } + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public Builder addCond( + com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.Builder builderForValue) { + if (condBuilder_ == null) { + ensureCondIsMutable(); + cond_.add(builderForValue.build()); + onChanged(); + } else { + condBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public Builder addCond( + int index, com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.Builder builderForValue) { + if (condBuilder_ == null) { + ensureCondIsMutable(); + cond_.add(index, builderForValue.build()); + onChanged(); + } else { + condBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public Builder addAllCond( + java.lang.Iterable values) { + if (condBuilder_ == null) { + ensureCondIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, cond_); + onChanged(); + } else { + condBuilder_.addAllMessages(values); + } + return this; + } + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public Builder clearCond() { + if (condBuilder_ == null) { + cond_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + } else { + condBuilder_.clear(); + } + return this; + } + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public Builder removeCond(int index) { + if (condBuilder_ == null) { + ensureCondIsMutable(); + cond_.remove(index); + onChanged(); + } else { + condBuilder_.remove(index); + } + return this; + } + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.Builder getCondBuilder( + int index) { + return getCondFieldBuilder().getBuilder(index); + } + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpect.Open.ConditionOrBuilder getCondOrBuilder( + int index) { + if (condBuilder_ == null) { + return cond_.get(index); } else { + return condBuilder_.getMessageOrBuilder(index); + } + } + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public java.util.List + getCondOrBuilderList() { + if (condBuilder_ != null) { + return condBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(cond_); + } + } + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.Builder addCondBuilder() { + return getCondFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.getDefaultInstance()); + } + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.Builder addCondBuilder( + int index) { + return getCondFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.getDefaultInstance()); + } + /** + * repeated .Mysqlx.Expect.Open.Condition cond = 2; + */ + public java.util.List + getCondBuilderList() { + return getCondFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition, com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.Builder, com.mysql.cj.x.protobuf.MysqlxExpect.Open.ConditionOrBuilder> + getCondFieldBuilder() { + if (condBuilder_ == null) { + condBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition, com.mysql.cj.x.protobuf.MysqlxExpect.Open.Condition.Builder, com.mysql.cj.x.protobuf.MysqlxExpect.Open.ConditionOrBuilder>( + cond_, + ((bitField0_ & 0x00000002) != 0), + getParentForChildren(), + isClean()); + cond_ = null; + } + return condBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Expect.Open) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Expect.Open) + private static final com.mysql.cj.x.protobuf.MysqlxExpect.Open DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxExpect.Open(); + } + + public static com.mysql.cj.x.protobuf.MysqlxExpect.Open getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Open parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Open(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpect.Open getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface CloseOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Expect.Close) + com.google.protobuf.MessageOrBuilder { + } + /** + * 
+   **
+   *Close a Expect block.
+   *Closing a Expect block restores the state of the previous Expect
+   *block for the following messages.
+   *@returns @ref Mysqlx::Ok on success,  @ref Mysqlx::Error on error
+   *
+ * + * Protobuf type {@code Mysqlx.Expect.Close} + */ + public static final class Close extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Expect.Close) + CloseOrBuilder { + private static final long serialVersionUID = 0L; + // Use Close.newBuilder() to construct. + private Close(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Close() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Close(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Close( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpect.internal_static_Mysqlx_Expect_Close_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpect.internal_static_Mysqlx_Expect_Close_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpect.Close.class, com.mysql.cj.x.protobuf.MysqlxExpect.Close.Builder.class); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxExpect.Close)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxExpect.Close other = (com.mysql.cj.x.protobuf.MysqlxExpect.Close) obj; + + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxExpect.Close parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Close parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Close parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Close parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Close parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Close parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Close parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Close parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Close parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Close parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Close parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpect.Close parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxExpect.Close prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Close a Expect block.
+     *Closing a Expect block restores the state of the previous Expect
+     *block for the following messages.
+     *@returns @ref Mysqlx::Ok on success,  @ref Mysqlx::Error on error
+     *
+ * + * Protobuf type {@code Mysqlx.Expect.Close} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Expect.Close) + com.mysql.cj.x.protobuf.MysqlxExpect.CloseOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpect.internal_static_Mysqlx_Expect_Close_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpect.internal_static_Mysqlx_Expect_Close_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpect.Close.class, com.mysql.cj.x.protobuf.MysqlxExpect.Close.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxExpect.Close.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxExpect.internal_static_Mysqlx_Expect_Close_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpect.Close getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxExpect.Close.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpect.Close build() { + com.mysql.cj.x.protobuf.MysqlxExpect.Close result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpect.Close buildPartial() { + com.mysql.cj.x.protobuf.MysqlxExpect.Close result = new com.mysql.cj.x.protobuf.MysqlxExpect.Close(this); + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxExpect.Close) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxExpect.Close)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxExpect.Close other) { + if (other == com.mysql.cj.x.protobuf.MysqlxExpect.Close.getDefaultInstance()) return this; + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxExpect.Close parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxExpect.Close) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Expect.Close) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Expect.Close) + private static final com.mysql.cj.x.protobuf.MysqlxExpect.Close DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxExpect.Close(); + } + + public static com.mysql.cj.x.protobuf.MysqlxExpect.Close getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Close parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Close(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpect.Close getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Expect_Open_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Expect_Open_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Expect_Open_Condition_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Expect_Open_Condition_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Expect_Close_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Expect_Close_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\023mysqlx_expect.proto\022\rMysqlx.Expect\032\014my" + + "sqlx.proto\"\326\003\n\004Open\022B\n\002op\030\001 \001(\0162 .Mysqlx" + + ".Expect.Open.CtxOperation:\024EXPECT_CTX_CO" + + "PY_PREV\022+\n\004cond\030\002 \003(\0132\035.Mysqlx.Expect.Op" + + "en.Condition\032\226\002\n\tCondition\022\025\n\rcondition_" + + "key\030\001 \002(\r\022\027\n\017condition_value\030\002 \001(\014\022K\n\002op" + + "\030\003 \001(\01620.Mysqlx.Expect.Open.Condition.Co" + + "nditionOperation:\rEXPECT_OP_SET\"N\n\003Key\022\023" + + "\n\017EXPECT_NO_ERROR\020\001\022\026\n\022EXPECT_FIELD_EXIS" + + "T\020\002\022\032\n\026EXPECT_DOCID_GENERATED\020\003\"<\n\022Condi" + + "tionOperation\022\021\n\rEXPECT_OP_SET\020\000\022\023\n\017EXPE" + + "CT_OP_UNSET\020\001\">\n\014CtxOperation\022\030\n\024EXPECT_" + + "CTX_COPY_PREV\020\000\022\024\n\020EXPECT_CTX_EMPTY\020\001:\004\210" + + "\3520\030\"\r\n\005Close:\004\210\3520\031B\031\n\027com.mysql.cj.x.pro" + + "tobuf" + }; + descriptor = com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + com.mysql.cj.x.protobuf.Mysqlx.getDescriptor(), + }); + internal_static_Mysqlx_Expect_Open_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_Mysqlx_Expect_Open_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Expect_Open_descriptor, + new java.lang.String[] { "Op", "Cond", }); + internal_static_Mysqlx_Expect_Open_Condition_descriptor = + internal_static_Mysqlx_Expect_Open_descriptor.getNestedTypes().get(0); + internal_static_Mysqlx_Expect_Open_Condition_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Expect_Open_Condition_descriptor, + new java.lang.String[] { "ConditionKey", "ConditionValue", "Op", }); + internal_static_Mysqlx_Expect_Close_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_Mysqlx_Expect_Close_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Expect_Close_descriptor, + new java.lang.String[] { }); + com.google.protobuf.ExtensionRegistry registry = + com.google.protobuf.ExtensionRegistry.newInstance(); + registry.add(com.mysql.cj.x.protobuf.Mysqlx.clientMessageId); + com.google.protobuf.Descriptors.FileDescriptor + .internalUpdateFileDescriptor(descriptor, registry); + com.mysql.cj.x.protobuf.Mysqlx.getDescriptor(); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxExpr.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxExpr.java new file mode 100644 index 0000000..f03038a --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxExpr.java @@ -0,0 +1,11117 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.x.protobuf; + +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: mysqlx_expr.proto + +@SuppressWarnings({ "deprecation" }) +public final class MysqlxExpr { + private MysqlxExpr() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + public interface ExprOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Expr.Expr) + com.google.protobuf.MessageOrBuilder { + + /** + * required .Mysqlx.Expr.Expr.Type type = 1; + * @return Whether the type field is set. + */ + boolean hasType(); + /** + * required .Mysqlx.Expr.Expr.Type type = 1; + * @return The type. + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Type getType(); + + /** + * optional .Mysqlx.Expr.ColumnIdentifier identifier = 2; + * @return Whether the identifier field is set. + */ + boolean hasIdentifier(); + /** + * optional .Mysqlx.Expr.ColumnIdentifier identifier = 2; + * @return The identifier. + */ + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier getIdentifier(); + /** + * optional .Mysqlx.Expr.ColumnIdentifier identifier = 2; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifierOrBuilder getIdentifierOrBuilder(); + + /** + * optional string variable = 3; + * @return Whether the variable field is set. + */ + boolean hasVariable(); + /** + * optional string variable = 3; + * @return The variable. + */ + java.lang.String getVariable(); + /** + * optional string variable = 3; + * @return The bytes for variable. + */ + com.google.protobuf.ByteString + getVariableBytes(); + + /** + * optional .Mysqlx.Datatypes.Scalar literal = 4; + * @return Whether the literal field is set. + */ + boolean hasLiteral(); + /** + * optional .Mysqlx.Datatypes.Scalar literal = 4; + * @return The literal. + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getLiteral(); + /** + * optional .Mysqlx.Datatypes.Scalar literal = 4; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getLiteralOrBuilder(); + + /** + * optional .Mysqlx.Expr.FunctionCall function_call = 5; + * @return Whether the functionCall field is set. + */ + boolean hasFunctionCall(); + /** + * optional .Mysqlx.Expr.FunctionCall function_call = 5; + * @return The functionCall. + */ + com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall getFunctionCall(); + /** + * optional .Mysqlx.Expr.FunctionCall function_call = 5; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCallOrBuilder getFunctionCallOrBuilder(); + + /** + * optional .Mysqlx.Expr.Operator operator = 6; + * @return Whether the operator field is set. + */ + boolean hasOperator(); + /** + * optional .Mysqlx.Expr.Operator operator = 6; + * @return The operator. + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Operator getOperator(); + /** + * optional .Mysqlx.Expr.Operator operator = 6; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.OperatorOrBuilder getOperatorOrBuilder(); + + /** + * optional uint32 position = 7; + * @return Whether the position field is set. + */ + boolean hasPosition(); + /** + * optional uint32 position = 7; + * @return The position. + */ + int getPosition(); + + /** + * optional .Mysqlx.Expr.Object object = 8; + * @return Whether the object field is set. + */ + boolean hasObject(); + /** + * optional .Mysqlx.Expr.Object object = 8; + * @return The object. + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Object getObject(); + /** + * optional .Mysqlx.Expr.Object object = 8; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.ObjectOrBuilder getObjectOrBuilder(); + + /** + * optional .Mysqlx.Expr.Array array = 9; + * @return Whether the array field is set. + */ + boolean hasArray(); + /** + * optional .Mysqlx.Expr.Array array = 9; + * @return The array. + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Array getArray(); + /** + * optional .Mysqlx.Expr.Array array = 9; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.ArrayOrBuilder getArrayOrBuilder(); + } + /** + * 
+   **
+   *The "root" of the expression tree.
+   *If expression type is PLACEHOLDER, then it refers to the value
+   *of a parameter specified when executing a statement (see args
+   *field of StmtExecute command). Field position (which must be
+   *present for such an expression) gives 0-based position of the
+   *parameter in the parameter list.
+   *@par production list
+   *@code{unparsed}
+   *expr: operator |
+   *: identifier |
+   *: function_call |
+   *: variable |
+   *: literal |
+   *: object |
+   *: array |
+   *: placeholder
+   *@endcode
+   *
+ * + * Protobuf type {@code Mysqlx.Expr.Expr} + */ + public static final class Expr extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Expr.Expr) + ExprOrBuilder { + private static final long serialVersionUID = 0L; + // Use Expr.newBuilder() to construct. + private Expr(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Expr() { + type_ = 1; + variable_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Expr(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Expr( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Type value = com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Type.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(1, rawValue); + } else { + bitField0_ |= 0x00000001; + type_ = rawValue; + } + break; + } + case 18: { + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) != 0)) { + subBuilder = identifier_.toBuilder(); + } + identifier_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(identifier_); + identifier_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000004; + variable_ = bs; + break; + } + case 34: { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) != 0)) { + subBuilder = literal_.toBuilder(); + } + literal_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(literal_); + literal_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + break; + } + case 42: { + com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall.Builder subBuilder = null; + if (((bitField0_ & 0x00000010) != 0)) { + subBuilder = functionCall_.toBuilder(); + } + functionCall_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(functionCall_); + functionCall_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000010; + break; + } + case 50: { + com.mysql.cj.x.protobuf.MysqlxExpr.Operator.Builder subBuilder = null; + if (((bitField0_ & 0x00000020) != 0)) { + subBuilder = operator_.toBuilder(); + } + operator_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.Operator.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(operator_); + operator_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000020; + break; + } + case 56: { + bitField0_ |= 0x00000040; + position_ = input.readUInt32(); + break; + } + case 66: { + com.mysql.cj.x.protobuf.MysqlxExpr.Object.Builder subBuilder = null; + if (((bitField0_ & 0x00000080) != 0)) { + subBuilder = object_.toBuilder(); + } + object_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.Object.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(object_); + object_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000080; + break; + } + case 74: { + com.mysql.cj.x.protobuf.MysqlxExpr.Array.Builder subBuilder = null; + if (((bitField0_ & 0x00000100) != 0)) { + subBuilder = array_.toBuilder(); + } + array_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.Array.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(array_); + array_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000100; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Expr_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Expr_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.class, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder.class); + } + + /** + * Protobuf enum {@code Mysqlx.Expr.Expr.Type} + */ + public enum Type + implements com.google.protobuf.ProtocolMessageEnum { + /** + * IDENT = 1; + */ + IDENT(1), + /** + * LITERAL = 2; + */ + LITERAL(2), + /** + * VARIABLE = 3; + */ + VARIABLE(3), + /** + * FUNC_CALL = 4; + */ + FUNC_CALL(4), + /** + * OPERATOR = 5; + */ + OPERATOR(5), + /** + * PLACEHOLDER = 6; + */ + PLACEHOLDER(6), + /** + * OBJECT = 7; + */ + OBJECT(7), + /** + * ARRAY = 8; + */ + ARRAY(8), + ; + + /** + * IDENT = 1; + */ + public static final int IDENT_VALUE = 1; + /** + * LITERAL = 2; + */ + public static final int LITERAL_VALUE = 2; + /** + * VARIABLE = 3; + */ + public static final int VARIABLE_VALUE = 3; + /** + * FUNC_CALL = 4; + */ + public static final int FUNC_CALL_VALUE = 4; + /** + * OPERATOR = 5; + */ + public static final int OPERATOR_VALUE = 5; + /** + * PLACEHOLDER = 6; + */ + public static final int PLACEHOLDER_VALUE = 6; + /** + * OBJECT = 7; + */ + public static final int OBJECT_VALUE = 7; + /** + * ARRAY = 8; + */ + public static final int ARRAY_VALUE = 8; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static Type valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static Type forNumber(int value) { + switch (value) { + case 1: return IDENT; + case 2: return LITERAL; + case 3: return VARIABLE; + case 4: return FUNC_CALL; + case 5: return OPERATOR; + case 6: return PLACEHOLDER; + case 7: return OBJECT; + case 8: return ARRAY; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + Type> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Type findValueByNumber(int number) { + return Type.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDescriptor().getEnumTypes().get(0); + } + + private static final Type[] VALUES = values(); + + public static Type valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private Type(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Expr.Expr.Type) + } + + private int bitField0_; + public static final int TYPE_FIELD_NUMBER = 1; + private int type_; + /** + * required .Mysqlx.Expr.Expr.Type type = 1; + * @return Whether the type field is set. + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required .Mysqlx.Expr.Expr.Type type = 1; + * @return The type. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Type getType() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Type result = com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Type.valueOf(type_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Type.IDENT : result; + } + + public static final int IDENTIFIER_FIELD_NUMBER = 2; + private com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier identifier_; + /** + * optional .Mysqlx.Expr.ColumnIdentifier identifier = 2; + * @return Whether the identifier field is set. + */ + public boolean hasIdentifier() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional .Mysqlx.Expr.ColumnIdentifier identifier = 2; + * @return The identifier. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier getIdentifier() { + return identifier_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.getDefaultInstance() : identifier_; + } + /** + * optional .Mysqlx.Expr.ColumnIdentifier identifier = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifierOrBuilder getIdentifierOrBuilder() { + return identifier_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.getDefaultInstance() : identifier_; + } + + public static final int VARIABLE_FIELD_NUMBER = 3; + private volatile java.lang.Object variable_; + /** + * optional string variable = 3; + * @return Whether the variable field is set. + */ + public boolean hasVariable() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * optional string variable = 3; + * @return The variable. + */ + public java.lang.String getVariable() { + java.lang.Object ref = variable_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + variable_ = s; + } + return s; + } + } + /** + * optional string variable = 3; + * @return The bytes for variable. + */ + public com.google.protobuf.ByteString + getVariableBytes() { + java.lang.Object ref = variable_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + variable_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int LITERAL_FIELD_NUMBER = 4; + private com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar literal_; + /** + * optional .Mysqlx.Datatypes.Scalar literal = 4; + * @return Whether the literal field is set. + */ + public boolean hasLiteral() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * optional .Mysqlx.Datatypes.Scalar literal = 4; + * @return The literal. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getLiteral() { + return literal_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance() : literal_; + } + /** + * optional .Mysqlx.Datatypes.Scalar literal = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getLiteralOrBuilder() { + return literal_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance() : literal_; + } + + public static final int FUNCTION_CALL_FIELD_NUMBER = 5; + private com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall functionCall_; + /** + * optional .Mysqlx.Expr.FunctionCall function_call = 5; + * @return Whether the functionCall field is set. + */ + public boolean hasFunctionCall() { + return ((bitField0_ & 0x00000010) != 0); + } + /** + * optional .Mysqlx.Expr.FunctionCall function_call = 5; + * @return The functionCall. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall getFunctionCall() { + return functionCall_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall.getDefaultInstance() : functionCall_; + } + /** + * optional .Mysqlx.Expr.FunctionCall function_call = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCallOrBuilder getFunctionCallOrBuilder() { + return functionCall_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall.getDefaultInstance() : functionCall_; + } + + public static final int OPERATOR_FIELD_NUMBER = 6; + private com.mysql.cj.x.protobuf.MysqlxExpr.Operator operator_; + /** + * optional .Mysqlx.Expr.Operator operator = 6; + * @return Whether the operator field is set. + */ + public boolean hasOperator() { + return ((bitField0_ & 0x00000020) != 0); + } + /** + * optional .Mysqlx.Expr.Operator operator = 6; + * @return The operator. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Operator getOperator() { + return operator_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Operator.getDefaultInstance() : operator_; + } + /** + * optional .Mysqlx.Expr.Operator operator = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.OperatorOrBuilder getOperatorOrBuilder() { + return operator_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Operator.getDefaultInstance() : operator_; + } + + public static final int POSITION_FIELD_NUMBER = 7; + private int position_; + /** + * optional uint32 position = 7; + * @return Whether the position field is set. + */ + public boolean hasPosition() { + return ((bitField0_ & 0x00000040) != 0); + } + /** + * optional uint32 position = 7; + * @return The position. + */ + public int getPosition() { + return position_; + } + + public static final int OBJECT_FIELD_NUMBER = 8; + private com.mysql.cj.x.protobuf.MysqlxExpr.Object object_; + /** + * optional .Mysqlx.Expr.Object object = 8; + * @return Whether the object field is set. + */ + public boolean hasObject() { + return ((bitField0_ & 0x00000080) != 0); + } + /** + * optional .Mysqlx.Expr.Object object = 8; + * @return The object. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Object getObject() { + return object_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Object.getDefaultInstance() : object_; + } + /** + * optional .Mysqlx.Expr.Object object = 8; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ObjectOrBuilder getObjectOrBuilder() { + return object_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Object.getDefaultInstance() : object_; + } + + public static final int ARRAY_FIELD_NUMBER = 9; + private com.mysql.cj.x.protobuf.MysqlxExpr.Array array_; + /** + * optional .Mysqlx.Expr.Array array = 9; + * @return Whether the array field is set. + */ + public boolean hasArray() { + return ((bitField0_ & 0x00000100) != 0); + } + /** + * optional .Mysqlx.Expr.Array array = 9; + * @return The array. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Array getArray() { + return array_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Array.getDefaultInstance() : array_; + } + /** + * optional .Mysqlx.Expr.Array array = 9; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ArrayOrBuilder getArrayOrBuilder() { + return array_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Array.getDefaultInstance() : array_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasType()) { + memoizedIsInitialized = 0; + return false; + } + if (hasIdentifier()) { + if (!getIdentifier().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasLiteral()) { + if (!getLiteral().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasFunctionCall()) { + if (!getFunctionCall().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasOperator()) { + if (!getOperator().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasObject()) { + if (!getObject().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasArray()) { + if (!getArray().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeEnum(1, type_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeMessage(2, getIdentifier()); + } + if (((bitField0_ & 0x00000004) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 3, variable_); + } + if (((bitField0_ & 0x00000008) != 0)) { + output.writeMessage(4, getLiteral()); + } + if (((bitField0_ & 0x00000010) != 0)) { + output.writeMessage(5, getFunctionCall()); + } + if (((bitField0_ & 0x00000020) != 0)) { + output.writeMessage(6, getOperator()); + } + if (((bitField0_ & 0x00000040) != 0)) { + output.writeUInt32(7, position_); + } + if (((bitField0_ & 0x00000080) != 0)) { + output.writeMessage(8, getObject()); + } + if (((bitField0_ & 0x00000100) != 0)) { + output.writeMessage(9, getArray()); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(1, type_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, getIdentifier()); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, variable_); + } + if (((bitField0_ & 0x00000008) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, getLiteral()); + } + if (((bitField0_ & 0x00000010) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(5, getFunctionCall()); + } + if (((bitField0_ & 0x00000020) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(6, getOperator()); + } + if (((bitField0_ & 0x00000040) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(7, position_); + } + if (((bitField0_ & 0x00000080) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(8, getObject()); + } + if (((bitField0_ & 0x00000100) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(9, getArray()); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxExpr.Expr)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxExpr.Expr other = (com.mysql.cj.x.protobuf.MysqlxExpr.Expr) obj; + + if (hasType() != other.hasType()) return false; + if (hasType()) { + if (type_ != other.type_) return false; + } + if (hasIdentifier() != other.hasIdentifier()) return false; + if (hasIdentifier()) { + if (!getIdentifier() + .equals(other.getIdentifier())) return false; + } + if (hasVariable() != other.hasVariable()) return false; + if (hasVariable()) { + if (!getVariable() + .equals(other.getVariable())) return false; + } + if (hasLiteral() != other.hasLiteral()) return false; + if (hasLiteral()) { + if (!getLiteral() + .equals(other.getLiteral())) return false; + } + if (hasFunctionCall() != other.hasFunctionCall()) return false; + if (hasFunctionCall()) { + if (!getFunctionCall() + .equals(other.getFunctionCall())) return false; + } + if (hasOperator() != other.hasOperator()) return false; + if (hasOperator()) { + if (!getOperator() + .equals(other.getOperator())) return false; + } + if (hasPosition() != other.hasPosition()) return false; + if (hasPosition()) { + if (getPosition() + != other.getPosition()) return false; + } + if (hasObject() != other.hasObject()) return false; + if (hasObject()) { + if (!getObject() + .equals(other.getObject())) return false; + } + if (hasArray() != other.hasArray()) return false; + if (hasArray()) { + if (!getArray() + .equals(other.getArray())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasType()) { + hash = (37 * hash) + TYPE_FIELD_NUMBER; + hash = (53 * hash) + type_; + } + if (hasIdentifier()) { + hash = (37 * hash) + IDENTIFIER_FIELD_NUMBER; + hash = (53 * hash) + getIdentifier().hashCode(); + } + if (hasVariable()) { + hash = (37 * hash) + VARIABLE_FIELD_NUMBER; + hash = (53 * hash) + getVariable().hashCode(); + } + if (hasLiteral()) { + hash = (37 * hash) + LITERAL_FIELD_NUMBER; + hash = (53 * hash) + getLiteral().hashCode(); + } + if (hasFunctionCall()) { + hash = (37 * hash) + FUNCTION_CALL_FIELD_NUMBER; + hash = (53 * hash) + getFunctionCall().hashCode(); + } + if (hasOperator()) { + hash = (37 * hash) + OPERATOR_FIELD_NUMBER; + hash = (53 * hash) + getOperator().hashCode(); + } + if (hasPosition()) { + hash = (37 * hash) + POSITION_FIELD_NUMBER; + hash = (53 * hash) + getPosition(); + } + if (hasObject()) { + hash = (37 * hash) + OBJECT_FIELD_NUMBER; + hash = (53 * hash) + getObject().hashCode(); + } + if (hasArray()) { + hash = (37 * hash) + ARRAY_FIELD_NUMBER; + hash = (53 * hash) + getArray().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxExpr.Expr parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Expr parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Expr parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Expr parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Expr parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Expr parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Expr parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Expr parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Expr parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Expr parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Expr parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Expr parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxExpr.Expr prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *The "root" of the expression tree.
+     *If expression type is PLACEHOLDER, then it refers to the value
+     *of a parameter specified when executing a statement (see args
+     *field of StmtExecute command). Field position (which must be
+     *present for such an expression) gives 0-based position of the
+     *parameter in the parameter list.
+     *@par production list
+     *@code{unparsed}
+     *expr: operator |
+     *: identifier |
+     *: function_call |
+     *: variable |
+     *: literal |
+     *: object |
+     *: array |
+     *: placeholder
+     *@endcode
+     *
+ * + * Protobuf type {@code Mysqlx.Expr.Expr} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Expr.Expr) + com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Expr_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Expr_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.class, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxExpr.Expr.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getIdentifierFieldBuilder(); + getLiteralFieldBuilder(); + getFunctionCallFieldBuilder(); + getOperatorFieldBuilder(); + getObjectFieldBuilder(); + getArrayFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + type_ = 1; + bitField0_ = (bitField0_ & ~0x00000001); + if (identifierBuilder_ == null) { + identifier_ = null; + } else { + identifierBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + variable_ = ""; + bitField0_ = (bitField0_ & ~0x00000004); + if (literalBuilder_ == null) { + literal_ = null; + } else { + literalBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + if (functionCallBuilder_ == null) { + functionCall_ = null; + } else { + functionCallBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000010); + if (operatorBuilder_ == null) { + operator_ = null; + } else { + operatorBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000020); + position_ = 0; + bitField0_ = (bitField0_ & ~0x00000040); + if (objectBuilder_ == null) { + object_ = null; + } else { + objectBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000080); + if (arrayBuilder_ == null) { + array_ = null; + } else { + arrayBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000100); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Expr_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr build() { + com.mysql.cj.x.protobuf.MysqlxExpr.Expr result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr buildPartial() { + com.mysql.cj.x.protobuf.MysqlxExpr.Expr result = new com.mysql.cj.x.protobuf.MysqlxExpr.Expr(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.type_ = type_; + if (((from_bitField0_ & 0x00000002) != 0)) { + if (identifierBuilder_ == null) { + result.identifier_ = identifier_; + } else { + result.identifier_ = identifierBuilder_.build(); + } + to_bitField0_ |= 0x00000002; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + to_bitField0_ |= 0x00000004; + } + result.variable_ = variable_; + if (((from_bitField0_ & 0x00000008) != 0)) { + if (literalBuilder_ == null) { + result.literal_ = literal_; + } else { + result.literal_ = literalBuilder_.build(); + } + to_bitField0_ |= 0x00000008; + } + if (((from_bitField0_ & 0x00000010) != 0)) { + if (functionCallBuilder_ == null) { + result.functionCall_ = functionCall_; + } else { + result.functionCall_ = functionCallBuilder_.build(); + } + to_bitField0_ |= 0x00000010; + } + if (((from_bitField0_ & 0x00000020) != 0)) { + if (operatorBuilder_ == null) { + result.operator_ = operator_; + } else { + result.operator_ = operatorBuilder_.build(); + } + to_bitField0_ |= 0x00000020; + } + if (((from_bitField0_ & 0x00000040) != 0)) { + result.position_ = position_; + to_bitField0_ |= 0x00000040; + } + if (((from_bitField0_ & 0x00000080) != 0)) { + if (objectBuilder_ == null) { + result.object_ = object_; + } else { + result.object_ = objectBuilder_.build(); + } + to_bitField0_ |= 0x00000080; + } + if (((from_bitField0_ & 0x00000100) != 0)) { + if (arrayBuilder_ == null) { + result.array_ = array_; + } else { + result.array_ = arrayBuilder_.build(); + } + to_bitField0_ |= 0x00000100; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxExpr.Expr) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxExpr.Expr)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxExpr.Expr other) { + if (other == com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance()) return this; + if (other.hasType()) { + setType(other.getType()); + } + if (other.hasIdentifier()) { + mergeIdentifier(other.getIdentifier()); + } + if (other.hasVariable()) { + bitField0_ |= 0x00000004; + variable_ = other.variable_; + onChanged(); + } + if (other.hasLiteral()) { + mergeLiteral(other.getLiteral()); + } + if (other.hasFunctionCall()) { + mergeFunctionCall(other.getFunctionCall()); + } + if (other.hasOperator()) { + mergeOperator(other.getOperator()); + } + if (other.hasPosition()) { + setPosition(other.getPosition()); + } + if (other.hasObject()) { + mergeObject(other.getObject()); + } + if (other.hasArray()) { + mergeArray(other.getArray()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasType()) { + return false; + } + if (hasIdentifier()) { + if (!getIdentifier().isInitialized()) { + return false; + } + } + if (hasLiteral()) { + if (!getLiteral().isInitialized()) { + return false; + } + } + if (hasFunctionCall()) { + if (!getFunctionCall().isInitialized()) { + return false; + } + } + if (hasOperator()) { + if (!getOperator().isInitialized()) { + return false; + } + } + if (hasObject()) { + if (!getObject().isInitialized()) { + return false; + } + } + if (hasArray()) { + if (!getArray().isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxExpr.Expr parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxExpr.Expr) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int type_ = 1; + /** + * required .Mysqlx.Expr.Expr.Type type = 1; + * @return Whether the type field is set. + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required .Mysqlx.Expr.Expr.Type type = 1; + * @return The type. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Type getType() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Type result = com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Type.valueOf(type_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Type.IDENT : result; + } + /** + * required .Mysqlx.Expr.Expr.Type type = 1; + * @param value The type to set. + * @return This builder for chaining. + */ + public Builder setType(com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Type value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + type_ = value.getNumber(); + onChanged(); + return this; + } + /** + * required .Mysqlx.Expr.Expr.Type type = 1; + * @return This builder for chaining. + */ + public Builder clearType() { + bitField0_ = (bitField0_ & ~0x00000001); + type_ = 1; + onChanged(); + return this; + } + + private com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier identifier_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier, com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifierOrBuilder> identifierBuilder_; + /** + * optional .Mysqlx.Expr.ColumnIdentifier identifier = 2; + * @return Whether the identifier field is set. + */ + public boolean hasIdentifier() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional .Mysqlx.Expr.ColumnIdentifier identifier = 2; + * @return The identifier. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier getIdentifier() { + if (identifierBuilder_ == null) { + return identifier_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.getDefaultInstance() : identifier_; + } else { + return identifierBuilder_.getMessage(); + } + } + /** + * optional .Mysqlx.Expr.ColumnIdentifier identifier = 2; + */ + public Builder setIdentifier(com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier value) { + if (identifierBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + identifier_ = value; + onChanged(); + } else { + identifierBuilder_.setMessage(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .Mysqlx.Expr.ColumnIdentifier identifier = 2; + */ + public Builder setIdentifier( + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.Builder builderForValue) { + if (identifierBuilder_ == null) { + identifier_ = builderForValue.build(); + onChanged(); + } else { + identifierBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .Mysqlx.Expr.ColumnIdentifier identifier = 2; + */ + public Builder mergeIdentifier(com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier value) { + if (identifierBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0) && + identifier_ != null && + identifier_ != com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.getDefaultInstance()) { + identifier_ = + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.newBuilder(identifier_).mergeFrom(value).buildPartial(); + } else { + identifier_ = value; + } + onChanged(); + } else { + identifierBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .Mysqlx.Expr.ColumnIdentifier identifier = 2; + */ + public Builder clearIdentifier() { + if (identifierBuilder_ == null) { + identifier_ = null; + onChanged(); + } else { + identifierBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + /** + * optional .Mysqlx.Expr.ColumnIdentifier identifier = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.Builder getIdentifierBuilder() { + bitField0_ |= 0x00000002; + onChanged(); + return getIdentifierFieldBuilder().getBuilder(); + } + /** + * optional .Mysqlx.Expr.ColumnIdentifier identifier = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifierOrBuilder getIdentifierOrBuilder() { + if (identifierBuilder_ != null) { + return identifierBuilder_.getMessageOrBuilder(); + } else { + return identifier_ == null ? + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.getDefaultInstance() : identifier_; + } + } + /** + * optional .Mysqlx.Expr.ColumnIdentifier identifier = 2; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier, com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifierOrBuilder> + getIdentifierFieldBuilder() { + if (identifierBuilder_ == null) { + identifierBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier, com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifierOrBuilder>( + getIdentifier(), + getParentForChildren(), + isClean()); + identifier_ = null; + } + return identifierBuilder_; + } + + private java.lang.Object variable_ = ""; + /** + * optional string variable = 3; + * @return Whether the variable field is set. + */ + public boolean hasVariable() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * optional string variable = 3; + * @return The variable. + */ + public java.lang.String getVariable() { + java.lang.Object ref = variable_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + variable_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string variable = 3; + * @return The bytes for variable. + */ + public com.google.protobuf.ByteString + getVariableBytes() { + java.lang.Object ref = variable_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + variable_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * optional string variable = 3; + * @param value The variable to set. + * @return This builder for chaining. + */ + public Builder setVariable( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + variable_ = value; + onChanged(); + return this; + } + /** + * optional string variable = 3; + * @return This builder for chaining. + */ + public Builder clearVariable() { + bitField0_ = (bitField0_ & ~0x00000004); + variable_ = getDefaultInstance().getVariable(); + onChanged(); + return this; + } + /** + * optional string variable = 3; + * @param value The bytes for variable to set. + * @return This builder for chaining. + */ + public Builder setVariableBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + variable_ = value; + onChanged(); + return this; + } + + private com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar literal_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder> literalBuilder_; + /** + * optional .Mysqlx.Datatypes.Scalar literal = 4; + * @return Whether the literal field is set. + */ + public boolean hasLiteral() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * optional .Mysqlx.Datatypes.Scalar literal = 4; + * @return The literal. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getLiteral() { + if (literalBuilder_ == null) { + return literal_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance() : literal_; + } else { + return literalBuilder_.getMessage(); + } + } + /** + * optional .Mysqlx.Datatypes.Scalar literal = 4; + */ + public Builder setLiteral(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value) { + if (literalBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + literal_ = value; + onChanged(); + } else { + literalBuilder_.setMessage(value); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .Mysqlx.Datatypes.Scalar literal = 4; + */ + public Builder setLiteral( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder builderForValue) { + if (literalBuilder_ == null) { + literal_ = builderForValue.build(); + onChanged(); + } else { + literalBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .Mysqlx.Datatypes.Scalar literal = 4; + */ + public Builder mergeLiteral(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value) { + if (literalBuilder_ == null) { + if (((bitField0_ & 0x00000008) != 0) && + literal_ != null && + literal_ != com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance()) { + literal_ = + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.newBuilder(literal_).mergeFrom(value).buildPartial(); + } else { + literal_ = value; + } + onChanged(); + } else { + literalBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .Mysqlx.Datatypes.Scalar literal = 4; + */ + public Builder clearLiteral() { + if (literalBuilder_ == null) { + literal_ = null; + onChanged(); + } else { + literalBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + /** + * optional .Mysqlx.Datatypes.Scalar literal = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder getLiteralBuilder() { + bitField0_ |= 0x00000008; + onChanged(); + return getLiteralFieldBuilder().getBuilder(); + } + /** + * optional .Mysqlx.Datatypes.Scalar literal = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getLiteralOrBuilder() { + if (literalBuilder_ != null) { + return literalBuilder_.getMessageOrBuilder(); + } else { + return literal_ == null ? + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance() : literal_; + } + } + /** + * optional .Mysqlx.Datatypes.Scalar literal = 4; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder> + getLiteralFieldBuilder() { + if (literalBuilder_ == null) { + literalBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder>( + getLiteral(), + getParentForChildren(), + isClean()); + literal_ = null; + } + return literalBuilder_; + } + + private com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall functionCall_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall, com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCallOrBuilder> functionCallBuilder_; + /** + * optional .Mysqlx.Expr.FunctionCall function_call = 5; + * @return Whether the functionCall field is set. + */ + public boolean hasFunctionCall() { + return ((bitField0_ & 0x00000010) != 0); + } + /** + * optional .Mysqlx.Expr.FunctionCall function_call = 5; + * @return The functionCall. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall getFunctionCall() { + if (functionCallBuilder_ == null) { + return functionCall_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall.getDefaultInstance() : functionCall_; + } else { + return functionCallBuilder_.getMessage(); + } + } + /** + * optional .Mysqlx.Expr.FunctionCall function_call = 5; + */ + public Builder setFunctionCall(com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall value) { + if (functionCallBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + functionCall_ = value; + onChanged(); + } else { + functionCallBuilder_.setMessage(value); + } + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .Mysqlx.Expr.FunctionCall function_call = 5; + */ + public Builder setFunctionCall( + com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall.Builder builderForValue) { + if (functionCallBuilder_ == null) { + functionCall_ = builderForValue.build(); + onChanged(); + } else { + functionCallBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .Mysqlx.Expr.FunctionCall function_call = 5; + */ + public Builder mergeFunctionCall(com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall value) { + if (functionCallBuilder_ == null) { + if (((bitField0_ & 0x00000010) != 0) && + functionCall_ != null && + functionCall_ != com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall.getDefaultInstance()) { + functionCall_ = + com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall.newBuilder(functionCall_).mergeFrom(value).buildPartial(); + } else { + functionCall_ = value; + } + onChanged(); + } else { + functionCallBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .Mysqlx.Expr.FunctionCall function_call = 5; + */ + public Builder clearFunctionCall() { + if (functionCallBuilder_ == null) { + functionCall_ = null; + onChanged(); + } else { + functionCallBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + /** + * optional .Mysqlx.Expr.FunctionCall function_call = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall.Builder getFunctionCallBuilder() { + bitField0_ |= 0x00000010; + onChanged(); + return getFunctionCallFieldBuilder().getBuilder(); + } + /** + * optional .Mysqlx.Expr.FunctionCall function_call = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCallOrBuilder getFunctionCallOrBuilder() { + if (functionCallBuilder_ != null) { + return functionCallBuilder_.getMessageOrBuilder(); + } else { + return functionCall_ == null ? + com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall.getDefaultInstance() : functionCall_; + } + } + /** + * optional .Mysqlx.Expr.FunctionCall function_call = 5; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall, com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCallOrBuilder> + getFunctionCallFieldBuilder() { + if (functionCallBuilder_ == null) { + functionCallBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall, com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCallOrBuilder>( + getFunctionCall(), + getParentForChildren(), + isClean()); + functionCall_ = null; + } + return functionCallBuilder_; + } + + private com.mysql.cj.x.protobuf.MysqlxExpr.Operator operator_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Operator, com.mysql.cj.x.protobuf.MysqlxExpr.Operator.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.OperatorOrBuilder> operatorBuilder_; + /** + * optional .Mysqlx.Expr.Operator operator = 6; + * @return Whether the operator field is set. + */ + public boolean hasOperator() { + return ((bitField0_ & 0x00000020) != 0); + } + /** + * optional .Mysqlx.Expr.Operator operator = 6; + * @return The operator. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Operator getOperator() { + if (operatorBuilder_ == null) { + return operator_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Operator.getDefaultInstance() : operator_; + } else { + return operatorBuilder_.getMessage(); + } + } + /** + * optional .Mysqlx.Expr.Operator operator = 6; + */ + public Builder setOperator(com.mysql.cj.x.protobuf.MysqlxExpr.Operator value) { + if (operatorBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + operator_ = value; + onChanged(); + } else { + operatorBuilder_.setMessage(value); + } + bitField0_ |= 0x00000020; + return this; + } + /** + * optional .Mysqlx.Expr.Operator operator = 6; + */ + public Builder setOperator( + com.mysql.cj.x.protobuf.MysqlxExpr.Operator.Builder builderForValue) { + if (operatorBuilder_ == null) { + operator_ = builderForValue.build(); + onChanged(); + } else { + operatorBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000020; + return this; + } + /** + * optional .Mysqlx.Expr.Operator operator = 6; + */ + public Builder mergeOperator(com.mysql.cj.x.protobuf.MysqlxExpr.Operator value) { + if (operatorBuilder_ == null) { + if (((bitField0_ & 0x00000020) != 0) && + operator_ != null && + operator_ != com.mysql.cj.x.protobuf.MysqlxExpr.Operator.getDefaultInstance()) { + operator_ = + com.mysql.cj.x.protobuf.MysqlxExpr.Operator.newBuilder(operator_).mergeFrom(value).buildPartial(); + } else { + operator_ = value; + } + onChanged(); + } else { + operatorBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000020; + return this; + } + /** + * optional .Mysqlx.Expr.Operator operator = 6; + */ + public Builder clearOperator() { + if (operatorBuilder_ == null) { + operator_ = null; + onChanged(); + } else { + operatorBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000020); + return this; + } + /** + * optional .Mysqlx.Expr.Operator operator = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Operator.Builder getOperatorBuilder() { + bitField0_ |= 0x00000020; + onChanged(); + return getOperatorFieldBuilder().getBuilder(); + } + /** + * optional .Mysqlx.Expr.Operator operator = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.OperatorOrBuilder getOperatorOrBuilder() { + if (operatorBuilder_ != null) { + return operatorBuilder_.getMessageOrBuilder(); + } else { + return operator_ == null ? + com.mysql.cj.x.protobuf.MysqlxExpr.Operator.getDefaultInstance() : operator_; + } + } + /** + * optional .Mysqlx.Expr.Operator operator = 6; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Operator, com.mysql.cj.x.protobuf.MysqlxExpr.Operator.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.OperatorOrBuilder> + getOperatorFieldBuilder() { + if (operatorBuilder_ == null) { + operatorBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Operator, com.mysql.cj.x.protobuf.MysqlxExpr.Operator.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.OperatorOrBuilder>( + getOperator(), + getParentForChildren(), + isClean()); + operator_ = null; + } + return operatorBuilder_; + } + + private int position_ ; + /** + * optional uint32 position = 7; + * @return Whether the position field is set. + */ + public boolean hasPosition() { + return ((bitField0_ & 0x00000040) != 0); + } + /** + * optional uint32 position = 7; + * @return The position. + */ + public int getPosition() { + return position_; + } + /** + * optional uint32 position = 7; + * @param value The position to set. + * @return This builder for chaining. + */ + public Builder setPosition(int value) { + bitField0_ |= 0x00000040; + position_ = value; + onChanged(); + return this; + } + /** + * optional uint32 position = 7; + * @return This builder for chaining. + */ + public Builder clearPosition() { + bitField0_ = (bitField0_ & ~0x00000040); + position_ = 0; + onChanged(); + return this; + } + + private com.mysql.cj.x.protobuf.MysqlxExpr.Object object_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Object, com.mysql.cj.x.protobuf.MysqlxExpr.Object.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ObjectOrBuilder> objectBuilder_; + /** + * optional .Mysqlx.Expr.Object object = 8; + * @return Whether the object field is set. + */ + public boolean hasObject() { + return ((bitField0_ & 0x00000080) != 0); + } + /** + * optional .Mysqlx.Expr.Object object = 8; + * @return The object. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Object getObject() { + if (objectBuilder_ == null) { + return object_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Object.getDefaultInstance() : object_; + } else { + return objectBuilder_.getMessage(); + } + } + /** + * optional .Mysqlx.Expr.Object object = 8; + */ + public Builder setObject(com.mysql.cj.x.protobuf.MysqlxExpr.Object value) { + if (objectBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + object_ = value; + onChanged(); + } else { + objectBuilder_.setMessage(value); + } + bitField0_ |= 0x00000080; + return this; + } + /** + * optional .Mysqlx.Expr.Object object = 8; + */ + public Builder setObject( + com.mysql.cj.x.protobuf.MysqlxExpr.Object.Builder builderForValue) { + if (objectBuilder_ == null) { + object_ = builderForValue.build(); + onChanged(); + } else { + objectBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000080; + return this; + } + /** + * optional .Mysqlx.Expr.Object object = 8; + */ + public Builder mergeObject(com.mysql.cj.x.protobuf.MysqlxExpr.Object value) { + if (objectBuilder_ == null) { + if (((bitField0_ & 0x00000080) != 0) && + object_ != null && + object_ != com.mysql.cj.x.protobuf.MysqlxExpr.Object.getDefaultInstance()) { + object_ = + com.mysql.cj.x.protobuf.MysqlxExpr.Object.newBuilder(object_).mergeFrom(value).buildPartial(); + } else { + object_ = value; + } + onChanged(); + } else { + objectBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000080; + return this; + } + /** + * optional .Mysqlx.Expr.Object object = 8; + */ + public Builder clearObject() { + if (objectBuilder_ == null) { + object_ = null; + onChanged(); + } else { + objectBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000080); + return this; + } + /** + * optional .Mysqlx.Expr.Object object = 8; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Object.Builder getObjectBuilder() { + bitField0_ |= 0x00000080; + onChanged(); + return getObjectFieldBuilder().getBuilder(); + } + /** + * optional .Mysqlx.Expr.Object object = 8; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ObjectOrBuilder getObjectOrBuilder() { + if (objectBuilder_ != null) { + return objectBuilder_.getMessageOrBuilder(); + } else { + return object_ == null ? + com.mysql.cj.x.protobuf.MysqlxExpr.Object.getDefaultInstance() : object_; + } + } + /** + * optional .Mysqlx.Expr.Object object = 8; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Object, com.mysql.cj.x.protobuf.MysqlxExpr.Object.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ObjectOrBuilder> + getObjectFieldBuilder() { + if (objectBuilder_ == null) { + objectBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Object, com.mysql.cj.x.protobuf.MysqlxExpr.Object.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ObjectOrBuilder>( + getObject(), + getParentForChildren(), + isClean()); + object_ = null; + } + return objectBuilder_; + } + + private com.mysql.cj.x.protobuf.MysqlxExpr.Array array_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Array, com.mysql.cj.x.protobuf.MysqlxExpr.Array.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ArrayOrBuilder> arrayBuilder_; + /** + * optional .Mysqlx.Expr.Array array = 9; + * @return Whether the array field is set. + */ + public boolean hasArray() { + return ((bitField0_ & 0x00000100) != 0); + } + /** + * optional .Mysqlx.Expr.Array array = 9; + * @return The array. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Array getArray() { + if (arrayBuilder_ == null) { + return array_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Array.getDefaultInstance() : array_; + } else { + return arrayBuilder_.getMessage(); + } + } + /** + * optional .Mysqlx.Expr.Array array = 9; + */ + public Builder setArray(com.mysql.cj.x.protobuf.MysqlxExpr.Array value) { + if (arrayBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + array_ = value; + onChanged(); + } else { + arrayBuilder_.setMessage(value); + } + bitField0_ |= 0x00000100; + return this; + } + /** + * optional .Mysqlx.Expr.Array array = 9; + */ + public Builder setArray( + com.mysql.cj.x.protobuf.MysqlxExpr.Array.Builder builderForValue) { + if (arrayBuilder_ == null) { + array_ = builderForValue.build(); + onChanged(); + } else { + arrayBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000100; + return this; + } + /** + * optional .Mysqlx.Expr.Array array = 9; + */ + public Builder mergeArray(com.mysql.cj.x.protobuf.MysqlxExpr.Array value) { + if (arrayBuilder_ == null) { + if (((bitField0_ & 0x00000100) != 0) && + array_ != null && + array_ != com.mysql.cj.x.protobuf.MysqlxExpr.Array.getDefaultInstance()) { + array_ = + com.mysql.cj.x.protobuf.MysqlxExpr.Array.newBuilder(array_).mergeFrom(value).buildPartial(); + } else { + array_ = value; + } + onChanged(); + } else { + arrayBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000100; + return this; + } + /** + * optional .Mysqlx.Expr.Array array = 9; + */ + public Builder clearArray() { + if (arrayBuilder_ == null) { + array_ = null; + onChanged(); + } else { + arrayBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000100); + return this; + } + /** + * optional .Mysqlx.Expr.Array array = 9; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Array.Builder getArrayBuilder() { + bitField0_ |= 0x00000100; + onChanged(); + return getArrayFieldBuilder().getBuilder(); + } + /** + * optional .Mysqlx.Expr.Array array = 9; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ArrayOrBuilder getArrayOrBuilder() { + if (arrayBuilder_ != null) { + return arrayBuilder_.getMessageOrBuilder(); + } else { + return array_ == null ? + com.mysql.cj.x.protobuf.MysqlxExpr.Array.getDefaultInstance() : array_; + } + } + /** + * optional .Mysqlx.Expr.Array array = 9; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Array, com.mysql.cj.x.protobuf.MysqlxExpr.Array.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ArrayOrBuilder> + getArrayFieldBuilder() { + if (arrayBuilder_ == null) { + arrayBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Array, com.mysql.cj.x.protobuf.MysqlxExpr.Array.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ArrayOrBuilder>( + getArray(), + getParentForChildren(), + isClean()); + array_ = null; + } + return arrayBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Expr.Expr) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Expr.Expr) + private static final com.mysql.cj.x.protobuf.MysqlxExpr.Expr DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxExpr.Expr(); + } + + public static com.mysql.cj.x.protobuf.MysqlxExpr.Expr getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Expr parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Expr(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface IdentifierOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Expr.Identifier) + com.google.protobuf.MessageOrBuilder { + + /** + * required string name = 1; + * @return Whether the name field is set. + */ + boolean hasName(); + /** + * required string name = 1; + * @return The name. + */ + java.lang.String getName(); + /** + * required string name = 1; + * @return The bytes for name. + */ + com.google.protobuf.ByteString + getNameBytes(); + + /** + * optional string schema_name = 2; + * @return Whether the schemaName field is set. + */ + boolean hasSchemaName(); + /** + * optional string schema_name = 2; + * @return The schemaName. + */ + java.lang.String getSchemaName(); + /** + * optional string schema_name = 2; + * @return The bytes for schemaName. + */ + com.google.protobuf.ByteString + getSchemaNameBytes(); + } + /** + * 
+   **
+   *Identifier: name, schame.name
+   *@par production list
+   *@code{unparsed}
+   *identifier: string "." string |
+   *: string
+   *@endcode
+   *
+ * + * Protobuf type {@code Mysqlx.Expr.Identifier} + */ + public static final class Identifier extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Expr.Identifier) + IdentifierOrBuilder { + private static final long serialVersionUID = 0L; + // Use Identifier.newBuilder() to construct. + private Identifier(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Identifier() { + name_ = ""; + schemaName_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Identifier(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Identifier( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000001; + name_ = bs; + break; + } + case 18: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000002; + schemaName_ = bs; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Identifier_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Identifier_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpr.Identifier.class, com.mysql.cj.x.protobuf.MysqlxExpr.Identifier.Builder.class); + } + + private int bitField0_; + public static final int NAME_FIELD_NUMBER = 1; + private volatile java.lang.Object name_; + /** + * required string name = 1; + * @return Whether the name field is set. + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required string name = 1; + * @return The name. + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } + } + /** + * required string name = 1; + * @return The bytes for name. + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int SCHEMA_NAME_FIELD_NUMBER = 2; + private volatile java.lang.Object schemaName_; + /** + * optional string schema_name = 2; + * @return Whether the schemaName field is set. + */ + public boolean hasSchemaName() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional string schema_name = 2; + * @return The schemaName. + */ + public java.lang.String getSchemaName() { + java.lang.Object ref = schemaName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + schemaName_ = s; + } + return s; + } + } + /** + * optional string schema_name = 2; + * @return The bytes for schemaName. + */ + public com.google.protobuf.ByteString + getSchemaNameBytes() { + java.lang.Object ref = schemaName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + schemaName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasName()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, name_); + } + if (((bitField0_ & 0x00000002) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, schemaName_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, name_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, schemaName_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxExpr.Identifier)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxExpr.Identifier other = (com.mysql.cj.x.protobuf.MysqlxExpr.Identifier) obj; + + if (hasName() != other.hasName()) return false; + if (hasName()) { + if (!getName() + .equals(other.getName())) return false; + } + if (hasSchemaName() != other.hasSchemaName()) return false; + if (hasSchemaName()) { + if (!getSchemaName() + .equals(other.getSchemaName())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasName()) { + hash = (37 * hash) + NAME_FIELD_NUMBER; + hash = (53 * hash) + getName().hashCode(); + } + if (hasSchemaName()) { + hash = (37 * hash) + SCHEMA_NAME_FIELD_NUMBER; + hash = (53 * hash) + getSchemaName().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxExpr.Identifier parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Identifier parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Identifier parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Identifier parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Identifier parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Identifier parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Identifier parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Identifier parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Identifier parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Identifier parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Identifier parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Identifier parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxExpr.Identifier prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Identifier: name, schame.name
+     *@par production list
+     *@code{unparsed}
+     *identifier: string "." string |
+     *: string
+     *@endcode
+     *
+ * + * Protobuf type {@code Mysqlx.Expr.Identifier} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Expr.Identifier) + com.mysql.cj.x.protobuf.MysqlxExpr.IdentifierOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Identifier_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Identifier_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpr.Identifier.class, com.mysql.cj.x.protobuf.MysqlxExpr.Identifier.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxExpr.Identifier.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + name_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + schemaName_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Identifier_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Identifier getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxExpr.Identifier.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Identifier build() { + com.mysql.cj.x.protobuf.MysqlxExpr.Identifier result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Identifier buildPartial() { + com.mysql.cj.x.protobuf.MysqlxExpr.Identifier result = new com.mysql.cj.x.protobuf.MysqlxExpr.Identifier(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.name_ = name_; + if (((from_bitField0_ & 0x00000002) != 0)) { + to_bitField0_ |= 0x00000002; + } + result.schemaName_ = schemaName_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxExpr.Identifier) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxExpr.Identifier)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxExpr.Identifier other) { + if (other == com.mysql.cj.x.protobuf.MysqlxExpr.Identifier.getDefaultInstance()) return this; + if (other.hasName()) { + bitField0_ |= 0x00000001; + name_ = other.name_; + onChanged(); + } + if (other.hasSchemaName()) { + bitField0_ |= 0x00000002; + schemaName_ = other.schemaName_; + onChanged(); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasName()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxExpr.Identifier parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxExpr.Identifier) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object name_ = ""; + /** + * required string name = 1; + * @return Whether the name field is set. + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required string name = 1; + * @return The name. + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * required string name = 1; + * @return The bytes for name. + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * required string name = 1; + * @param value The name to set. + * @return This builder for chaining. + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + name_ = value; + onChanged(); + return this; + } + /** + * required string name = 1; + * @return This builder for chaining. + */ + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000001); + name_ = getDefaultInstance().getName(); + onChanged(); + return this; + } + /** + * required string name = 1; + * @param value The bytes for name to set. + * @return This builder for chaining. + */ + public Builder setNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + name_ = value; + onChanged(); + return this; + } + + private java.lang.Object schemaName_ = ""; + /** + * optional string schema_name = 2; + * @return Whether the schemaName field is set. + */ + public boolean hasSchemaName() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional string schema_name = 2; + * @return The schemaName. + */ + public java.lang.String getSchemaName() { + java.lang.Object ref = schemaName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + schemaName_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string schema_name = 2; + * @return The bytes for schemaName. + */ + public com.google.protobuf.ByteString + getSchemaNameBytes() { + java.lang.Object ref = schemaName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + schemaName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * optional string schema_name = 2; + * @param value The schemaName to set. + * @return This builder for chaining. + */ + public Builder setSchemaName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + schemaName_ = value; + onChanged(); + return this; + } + /** + * optional string schema_name = 2; + * @return This builder for chaining. + */ + public Builder clearSchemaName() { + bitField0_ = (bitField0_ & ~0x00000002); + schemaName_ = getDefaultInstance().getSchemaName(); + onChanged(); + return this; + } + /** + * optional string schema_name = 2; + * @param value The bytes for schemaName to set. + * @return This builder for chaining. + */ + public Builder setSchemaNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + schemaName_ = value; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Expr.Identifier) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Expr.Identifier) + private static final com.mysql.cj.x.protobuf.MysqlxExpr.Identifier DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxExpr.Identifier(); + } + + public static com.mysql.cj.x.protobuf.MysqlxExpr.Identifier getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Identifier parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Identifier(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Identifier getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface DocumentPathItemOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Expr.DocumentPathItem) + com.google.protobuf.MessageOrBuilder { + + /** + * required .Mysqlx.Expr.DocumentPathItem.Type type = 1; + * @return Whether the type field is set. + */ + boolean hasType(); + /** + * required .Mysqlx.Expr.DocumentPathItem.Type type = 1; + * @return The type. + */ + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Type getType(); + + /** + * optional string value = 2; + * @return Whether the value field is set. + */ + boolean hasValue(); + /** + * optional string value = 2; + * @return The value. + */ + java.lang.String getValue(); + /** + * optional string value = 2; + * @return The bytes for value. + */ + com.google.protobuf.ByteString + getValueBytes(); + + /** + * 
+     ** used in case of ARRY_INDEX 
+     *
+ * + * optional uint32 index = 3; + * @return Whether the index field is set. + */ + boolean hasIndex(); + /** + * 
+     ** used in case of ARRY_INDEX 
+     *
+ * + * optional uint32 index = 3; + * @return The index. + */ + int getIndex(); + } + /** + * 
+   **
+   *Document path item
+   *@par production list
+   *@code{unparsed}
+   *document_path: path_item | path_item document_path
+   *path_item    : member | array_index | "**"
+   *member       : "." string | "." "*"
+   *array_index  : "[" number "]" | "[" "*" "]"
+   *@endcode
+   *
+ * + * Protobuf type {@code Mysqlx.Expr.DocumentPathItem} + */ + public static final class DocumentPathItem extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Expr.DocumentPathItem) + DocumentPathItemOrBuilder { + private static final long serialVersionUID = 0L; + // Use DocumentPathItem.newBuilder() to construct. + private DocumentPathItem(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private DocumentPathItem() { + type_ = 1; + value_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new DocumentPathItem(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private DocumentPathItem( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Type value = com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Type.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(1, rawValue); + } else { + bitField0_ |= 0x00000001; + type_ = rawValue; + } + break; + } + case 18: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000002; + value_ = bs; + break; + } + case 24: { + bitField0_ |= 0x00000004; + index_ = input.readUInt32(); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_DocumentPathItem_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_DocumentPathItem_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.class, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Builder.class); + } + + /** + * Protobuf enum {@code Mysqlx.Expr.DocumentPathItem.Type} + */ + public enum Type + implements com.google.protobuf.ProtocolMessageEnum { + /** + * 
+       **  .member 
+       *
+ * + * MEMBER = 1; + */ + MEMBER(1), + /** + * 
+       ** \.* 
+       *
+ * + * MEMBER_ASTERISK = 2; + */ + MEMBER_ASTERISK(2), + /** + * 
+       ** [index] 
+       *
+ * + * ARRAY_INDEX = 3; + */ + ARRAY_INDEX(3), + /** + * 
+       ** [*] 
+       *
+ * + * ARRAY_INDEX_ASTERISK = 4; + */ + ARRAY_INDEX_ASTERISK(4), + /** + * 
+       ** ** 
+       *
+ * + * DOUBLE_ASTERISK = 5; + */ + DOUBLE_ASTERISK(5), + ; + + /** + * 
+       **  .member 
+       *
+ * + * MEMBER = 1; + */ + public static final int MEMBER_VALUE = 1; + /** + * 
+       ** \.* 
+       *
+ * + * MEMBER_ASTERISK = 2; + */ + public static final int MEMBER_ASTERISK_VALUE = 2; + /** + * 
+       ** [index] 
+       *
+ * + * ARRAY_INDEX = 3; + */ + public static final int ARRAY_INDEX_VALUE = 3; + /** + * 
+       ** [*] 
+       *
+ * + * ARRAY_INDEX_ASTERISK = 4; + */ + public static final int ARRAY_INDEX_ASTERISK_VALUE = 4; + /** + * 
+       ** ** 
+       *
+ * + * DOUBLE_ASTERISK = 5; + */ + public static final int DOUBLE_ASTERISK_VALUE = 5; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static Type valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static Type forNumber(int value) { + switch (value) { + case 1: return MEMBER; + case 2: return MEMBER_ASTERISK; + case 3: return ARRAY_INDEX; + case 4: return ARRAY_INDEX_ASTERISK; + case 5: return DOUBLE_ASTERISK; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + Type> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Type findValueByNumber(int number) { + return Type.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.getDescriptor().getEnumTypes().get(0); + } + + private static final Type[] VALUES = values(); + + public static Type valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private Type(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Expr.DocumentPathItem.Type) + } + + private int bitField0_; + public static final int TYPE_FIELD_NUMBER = 1; + private int type_; + /** + * required .Mysqlx.Expr.DocumentPathItem.Type type = 1; + * @return Whether the type field is set. + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required .Mysqlx.Expr.DocumentPathItem.Type type = 1; + * @return The type. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Type getType() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Type result = com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Type.valueOf(type_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Type.MEMBER : result; + } + + public static final int VALUE_FIELD_NUMBER = 2; + private volatile java.lang.Object value_; + /** + * optional string value = 2; + * @return Whether the value field is set. + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional string value = 2; + * @return The value. + */ + public java.lang.String getValue() { + java.lang.Object ref = value_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + value_ = s; + } + return s; + } + } + /** + * optional string value = 2; + * @return The bytes for value. + */ + public com.google.protobuf.ByteString + getValueBytes() { + java.lang.Object ref = value_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + value_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int INDEX_FIELD_NUMBER = 3; + private int index_; + /** + * 
+     ** used in case of ARRY_INDEX 
+     *
+ * + * optional uint32 index = 3; + * @return Whether the index field is set. + */ + public boolean hasIndex() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+     ** used in case of ARRY_INDEX 
+     *
+ * + * optional uint32 index = 3; + * @return The index. + */ + public int getIndex() { + return index_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasType()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeEnum(1, type_); + } + if (((bitField0_ & 0x00000002) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, value_); + } + if (((bitField0_ & 0x00000004) != 0)) { + output.writeUInt32(3, index_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(1, type_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, value_); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(3, index_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem other = (com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem) obj; + + if (hasType() != other.hasType()) return false; + if (hasType()) { + if (type_ != other.type_) return false; + } + if (hasValue() != other.hasValue()) return false; + if (hasValue()) { + if (!getValue() + .equals(other.getValue())) return false; + } + if (hasIndex() != other.hasIndex()) return false; + if (hasIndex()) { + if (getIndex() + != other.getIndex()) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasType()) { + hash = (37 * hash) + TYPE_FIELD_NUMBER; + hash = (53 * hash) + type_; + } + if (hasValue()) { + hash = (37 * hash) + VALUE_FIELD_NUMBER; + hash = (53 * hash) + getValue().hashCode(); + } + if (hasIndex()) { + hash = (37 * hash) + INDEX_FIELD_NUMBER; + hash = (53 * hash) + getIndex(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Document path item
+     *@par production list
+     *@code{unparsed}
+     *document_path: path_item | path_item document_path
+     *path_item    : member | array_index | "**"
+     *member       : "." string | "." "*"
+     *array_index  : "[" number "]" | "[" "*" "]"
+     *@endcode
+     *
+ * + * Protobuf type {@code Mysqlx.Expr.DocumentPathItem} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Expr.DocumentPathItem) + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItemOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_DocumentPathItem_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_DocumentPathItem_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.class, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + type_ = 1; + bitField0_ = (bitField0_ & ~0x00000001); + value_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + index_ = 0; + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_DocumentPathItem_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem build() { + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem buildPartial() { + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem result = new com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.type_ = type_; + if (((from_bitField0_ & 0x00000002) != 0)) { + to_bitField0_ |= 0x00000002; + } + result.value_ = value_; + if (((from_bitField0_ & 0x00000004) != 0)) { + result.index_ = index_; + to_bitField0_ |= 0x00000004; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem other) { + if (other == com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.getDefaultInstance()) return this; + if (other.hasType()) { + setType(other.getType()); + } + if (other.hasValue()) { + bitField0_ |= 0x00000002; + value_ = other.value_; + onChanged(); + } + if (other.hasIndex()) { + setIndex(other.getIndex()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasType()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int type_ = 1; + /** + * required .Mysqlx.Expr.DocumentPathItem.Type type = 1; + * @return Whether the type field is set. + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required .Mysqlx.Expr.DocumentPathItem.Type type = 1; + * @return The type. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Type getType() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Type result = com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Type.valueOf(type_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Type.MEMBER : result; + } + /** + * required .Mysqlx.Expr.DocumentPathItem.Type type = 1; + * @param value The type to set. + * @return This builder for chaining. + */ + public Builder setType(com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Type value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + type_ = value.getNumber(); + onChanged(); + return this; + } + /** + * required .Mysqlx.Expr.DocumentPathItem.Type type = 1; + * @return This builder for chaining. + */ + public Builder clearType() { + bitField0_ = (bitField0_ & ~0x00000001); + type_ = 1; + onChanged(); + return this; + } + + private java.lang.Object value_ = ""; + /** + * optional string value = 2; + * @return Whether the value field is set. + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional string value = 2; + * @return The value. + */ + public java.lang.String getValue() { + java.lang.Object ref = value_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + value_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * optional string value = 2; + * @return The bytes for value. + */ + public com.google.protobuf.ByteString + getValueBytes() { + java.lang.Object ref = value_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + value_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * optional string value = 2; + * @param value The value to set. + * @return This builder for chaining. + */ + public Builder setValue( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + value_ = value; + onChanged(); + return this; + } + /** + * optional string value = 2; + * @return This builder for chaining. + */ + public Builder clearValue() { + bitField0_ = (bitField0_ & ~0x00000002); + value_ = getDefaultInstance().getValue(); + onChanged(); + return this; + } + /** + * optional string value = 2; + * @param value The bytes for value to set. + * @return This builder for chaining. + */ + public Builder setValueBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + value_ = value; + onChanged(); + return this; + } + + private int index_ ; + /** + * 
+       ** used in case of ARRY_INDEX 
+       *
+ * + * optional uint32 index = 3; + * @return Whether the index field is set. + */ + public boolean hasIndex() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+       ** used in case of ARRY_INDEX 
+       *
+ * + * optional uint32 index = 3; + * @return The index. + */ + public int getIndex() { + return index_; + } + /** + * 
+       ** used in case of ARRY_INDEX 
+       *
+ * + * optional uint32 index = 3; + * @param value The index to set. + * @return This builder for chaining. + */ + public Builder setIndex(int value) { + bitField0_ |= 0x00000004; + index_ = value; + onChanged(); + return this; + } + /** + * 
+       ** used in case of ARRY_INDEX 
+       *
+ * + * optional uint32 index = 3; + * @return This builder for chaining. + */ + public Builder clearIndex() { + bitField0_ = (bitField0_ & ~0x00000004); + index_ = 0; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Expr.DocumentPathItem) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Expr.DocumentPathItem) + private static final com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem(); + } + + public static com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public DocumentPathItem parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new DocumentPathItem(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ColumnIdentifierOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Expr.ColumnIdentifier) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** document path 
+     *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + java.util.List + getDocumentPathList(); + /** + * 
+     ** document path 
+     *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem getDocumentPath(int index); + /** + * 
+     ** document path 
+     *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + int getDocumentPathCount(); + /** + * 
+     ** document path 
+     *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + java.util.List + getDocumentPathOrBuilderList(); + /** + * 
+     ** document path 
+     *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItemOrBuilder getDocumentPathOrBuilder( + int index); + + /** + * 
+     ** name of column 
+     *
+ * + * optional string name = 2; + * @return Whether the name field is set. + */ + boolean hasName(); + /** + * 
+     ** name of column 
+     *
+ * + * optional string name = 2; + * @return The name. + */ + java.lang.String getName(); + /** + * 
+     ** name of column 
+     *
+ * + * optional string name = 2; + * @return The bytes for name. + */ + com.google.protobuf.ByteString + getNameBytes(); + + /** + * 
+     ** name of table 
+     *
+ * + * optional string table_name = 3; + * @return Whether the tableName field is set. + */ + boolean hasTableName(); + /** + * 
+     ** name of table 
+     *
+ * + * optional string table_name = 3; + * @return The tableName. + */ + java.lang.String getTableName(); + /** + * 
+     ** name of table 
+     *
+ * + * optional string table_name = 3; + * @return The bytes for tableName. + */ + com.google.protobuf.ByteString + getTableNameBytes(); + + /** + * 
+     ** name of schema 
+     *
+ * + * optional string schema_name = 4; + * @return Whether the schemaName field is set. + */ + boolean hasSchemaName(); + /** + * 
+     ** name of schema 
+     *
+ * + * optional string schema_name = 4; + * @return The schemaName. + */ + java.lang.String getSchemaName(); + /** + * 
+     ** name of schema 
+     *
+ * + * optional string schema_name = 4; + * @return The bytes for schemaName. + */ + com.google.protobuf.ByteString + getSchemaNameBytes(); + } + /** + * 
+   **
+   *Column identifier
+   *for table: col\@doc_path, tbl.col\@doc_path col, tbl.col, schema.tbl.col
+   *for document collection: doc_path
+   * //
+   *@par production list
+   *@code{unparsed}
+   *col_identifier: string "." string "." string |
+   *: string "." string |
+   *: string |
+   *: string "." string "." string "@" document_path |
+   *: string "." string "@" document_path |
+   *: string "@" document_path |
+   *: document_path
+   *document_path: member | arrayLocation | doubleAsterisk
+   *member = "." string | "." "*"
+   *arrayLocation = "[" index "]" | "[" "*" "]"
+   *doubleAsterisk = "**"
+   *@endcode
+   *
+ * + * Protobuf type {@code Mysqlx.Expr.ColumnIdentifier} + */ + public static final class ColumnIdentifier extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Expr.ColumnIdentifier) + ColumnIdentifierOrBuilder { + private static final long serialVersionUID = 0L; + // Use ColumnIdentifier.newBuilder() to construct. + private ColumnIdentifier(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private ColumnIdentifier() { + documentPath_ = java.util.Collections.emptyList(); + name_ = ""; + tableName_ = ""; + schemaName_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new ColumnIdentifier(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private ColumnIdentifier( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + if (!((mutable_bitField0_ & 0x00000001) != 0)) { + documentPath_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + documentPath_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.PARSER, extensionRegistry)); + break; + } + case 18: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000001; + name_ = bs; + break; + } + case 26: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000002; + tableName_ = bs; + break; + } + case 34: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000004; + schemaName_ = bs; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000001) != 0)) { + documentPath_ = java.util.Collections.unmodifiableList(documentPath_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_ColumnIdentifier_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_ColumnIdentifier_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.class, com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.Builder.class); + } + + private int bitField0_; + public static final int DOCUMENT_PATH_FIELD_NUMBER = 1; + private java.util.List documentPath_; + /** + * 
+     ** document path 
+     *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public java.util.List getDocumentPathList() { + return documentPath_; + } + /** + * 
+     ** document path 
+     *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public java.util.List + getDocumentPathOrBuilderList() { + return documentPath_; + } + /** + * 
+     ** document path 
+     *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public int getDocumentPathCount() { + return documentPath_.size(); + } + /** + * 
+     ** document path 
+     *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem getDocumentPath(int index) { + return documentPath_.get(index); + } + /** + * 
+     ** document path 
+     *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItemOrBuilder getDocumentPathOrBuilder( + int index) { + return documentPath_.get(index); + } + + public static final int NAME_FIELD_NUMBER = 2; + private volatile java.lang.Object name_; + /** + * 
+     ** name of column 
+     *
+ * + * optional string name = 2; + * @return Whether the name field is set. + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** name of column 
+     *
+ * + * optional string name = 2; + * @return The name. + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } + } + /** + * 
+     ** name of column 
+     *
+ * + * optional string name = 2; + * @return The bytes for name. + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int TABLE_NAME_FIELD_NUMBER = 3; + private volatile java.lang.Object tableName_; + /** + * 
+     ** name of table 
+     *
+ * + * optional string table_name = 3; + * @return Whether the tableName field is set. + */ + public boolean hasTableName() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** name of table 
+     *
+ * + * optional string table_name = 3; + * @return The tableName. + */ + public java.lang.String getTableName() { + java.lang.Object ref = tableName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + tableName_ = s; + } + return s; + } + } + /** + * 
+     ** name of table 
+     *
+ * + * optional string table_name = 3; + * @return The bytes for tableName. + */ + public com.google.protobuf.ByteString + getTableNameBytes() { + java.lang.Object ref = tableName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + tableName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int SCHEMA_NAME_FIELD_NUMBER = 4; + private volatile java.lang.Object schemaName_; + /** + * 
+     ** name of schema 
+     *
+ * + * optional string schema_name = 4; + * @return Whether the schemaName field is set. + */ + public boolean hasSchemaName() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+     ** name of schema 
+     *
+ * + * optional string schema_name = 4; + * @return The schemaName. + */ + public java.lang.String getSchemaName() { + java.lang.Object ref = schemaName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + schemaName_ = s; + } + return s; + } + } + /** + * 
+     ** name of schema 
+     *
+ * + * optional string schema_name = 4; + * @return The bytes for schemaName. + */ + public com.google.protobuf.ByteString + getSchemaNameBytes() { + java.lang.Object ref = schemaName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + schemaName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + for (int i = 0; i < getDocumentPathCount(); i++) { + if (!getDocumentPath(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < documentPath_.size(); i++) { + output.writeMessage(1, documentPath_.get(i)); + } + if (((bitField0_ & 0x00000001) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, name_); + } + if (((bitField0_ & 0x00000002) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 3, tableName_); + } + if (((bitField0_ & 0x00000004) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 4, schemaName_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < documentPath_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, documentPath_.get(i)); + } + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, name_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, tableName_); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(4, schemaName_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier other = (com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier) obj; + + if (!getDocumentPathList() + .equals(other.getDocumentPathList())) return false; + if (hasName() != other.hasName()) return false; + if (hasName()) { + if (!getName() + .equals(other.getName())) return false; + } + if (hasTableName() != other.hasTableName()) return false; + if (hasTableName()) { + if (!getTableName() + .equals(other.getTableName())) return false; + } + if (hasSchemaName() != other.hasSchemaName()) return false; + if (hasSchemaName()) { + if (!getSchemaName() + .equals(other.getSchemaName())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getDocumentPathCount() > 0) { + hash = (37 * hash) + DOCUMENT_PATH_FIELD_NUMBER; + hash = (53 * hash) + getDocumentPathList().hashCode(); + } + if (hasName()) { + hash = (37 * hash) + NAME_FIELD_NUMBER; + hash = (53 * hash) + getName().hashCode(); + } + if (hasTableName()) { + hash = (37 * hash) + TABLE_NAME_FIELD_NUMBER; + hash = (53 * hash) + getTableName().hashCode(); + } + if (hasSchemaName()) { + hash = (37 * hash) + SCHEMA_NAME_FIELD_NUMBER; + hash = (53 * hash) + getSchemaName().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Column identifier
+     *for table: col\@doc_path, tbl.col\@doc_path col, tbl.col, schema.tbl.col
+     *for document collection: doc_path
+     * //
+     *@par production list
+     *@code{unparsed}
+     *col_identifier: string "." string "." string |
+     *: string "." string |
+     *: string |
+     *: string "." string "." string "@" document_path |
+     *: string "." string "@" document_path |
+     *: string "@" document_path |
+     *: document_path
+     *document_path: member | arrayLocation | doubleAsterisk
+     *member = "." string | "." "*"
+     *arrayLocation = "[" index "]" | "[" "*" "]"
+     *doubleAsterisk = "**"
+     *@endcode
+     *
+ * + * Protobuf type {@code Mysqlx.Expr.ColumnIdentifier} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Expr.ColumnIdentifier) + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifierOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_ColumnIdentifier_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_ColumnIdentifier_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.class, com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getDocumentPathFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + if (documentPathBuilder_ == null) { + documentPath_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + } else { + documentPathBuilder_.clear(); + } + name_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + tableName_ = ""; + bitField0_ = (bitField0_ & ~0x00000004); + schemaName_ = ""; + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_ColumnIdentifier_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier build() { + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier buildPartial() { + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier result = new com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (documentPathBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0)) { + documentPath_ = java.util.Collections.unmodifiableList(documentPath_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.documentPath_ = documentPath_; + } else { + result.documentPath_ = documentPathBuilder_.build(); + } + if (((from_bitField0_ & 0x00000002) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.name_ = name_; + if (((from_bitField0_ & 0x00000004) != 0)) { + to_bitField0_ |= 0x00000002; + } + result.tableName_ = tableName_; + if (((from_bitField0_ & 0x00000008) != 0)) { + to_bitField0_ |= 0x00000004; + } + result.schemaName_ = schemaName_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier other) { + if (other == com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier.getDefaultInstance()) return this; + if (documentPathBuilder_ == null) { + if (!other.documentPath_.isEmpty()) { + if (documentPath_.isEmpty()) { + documentPath_ = other.documentPath_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureDocumentPathIsMutable(); + documentPath_.addAll(other.documentPath_); + } + onChanged(); + } + } else { + if (!other.documentPath_.isEmpty()) { + if (documentPathBuilder_.isEmpty()) { + documentPathBuilder_.dispose(); + documentPathBuilder_ = null; + documentPath_ = other.documentPath_; + bitField0_ = (bitField0_ & ~0x00000001); + documentPathBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getDocumentPathFieldBuilder() : null; + } else { + documentPathBuilder_.addAllMessages(other.documentPath_); + } + } + } + if (other.hasName()) { + bitField0_ |= 0x00000002; + name_ = other.name_; + onChanged(); + } + if (other.hasTableName()) { + bitField0_ |= 0x00000004; + tableName_ = other.tableName_; + onChanged(); + } + if (other.hasSchemaName()) { + bitField0_ |= 0x00000008; + schemaName_ = other.schemaName_; + onChanged(); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + for (int i = 0; i < getDocumentPathCount(); i++) { + if (!getDocumentPath(i).isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List documentPath_ = + java.util.Collections.emptyList(); + private void ensureDocumentPathIsMutable() { + if (!((bitField0_ & 0x00000001) != 0)) { + documentPath_ = new java.util.ArrayList(documentPath_); + bitField0_ |= 0x00000001; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItemOrBuilder> documentPathBuilder_; + + /** + * 
+       ** document path 
+       *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public java.util.List getDocumentPathList() { + if (documentPathBuilder_ == null) { + return java.util.Collections.unmodifiableList(documentPath_); + } else { + return documentPathBuilder_.getMessageList(); + } + } + /** + * 
+       ** document path 
+       *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public int getDocumentPathCount() { + if (documentPathBuilder_ == null) { + return documentPath_.size(); + } else { + return documentPathBuilder_.getCount(); + } + } + /** + * 
+       ** document path 
+       *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem getDocumentPath(int index) { + if (documentPathBuilder_ == null) { + return documentPath_.get(index); + } else { + return documentPathBuilder_.getMessage(index); + } + } + /** + * 
+       ** document path 
+       *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public Builder setDocumentPath( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem value) { + if (documentPathBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureDocumentPathIsMutable(); + documentPath_.set(index, value); + onChanged(); + } else { + documentPathBuilder_.setMessage(index, value); + } + return this; + } + /** + * 
+       ** document path 
+       *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public Builder setDocumentPath( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Builder builderForValue) { + if (documentPathBuilder_ == null) { + ensureDocumentPathIsMutable(); + documentPath_.set(index, builderForValue.build()); + onChanged(); + } else { + documentPathBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** document path 
+       *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public Builder addDocumentPath(com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem value) { + if (documentPathBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureDocumentPathIsMutable(); + documentPath_.add(value); + onChanged(); + } else { + documentPathBuilder_.addMessage(value); + } + return this; + } + /** + * 
+       ** document path 
+       *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public Builder addDocumentPath( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem value) { + if (documentPathBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureDocumentPathIsMutable(); + documentPath_.add(index, value); + onChanged(); + } else { + documentPathBuilder_.addMessage(index, value); + } + return this; + } + /** + * 
+       ** document path 
+       *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public Builder addDocumentPath( + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Builder builderForValue) { + if (documentPathBuilder_ == null) { + ensureDocumentPathIsMutable(); + documentPath_.add(builderForValue.build()); + onChanged(); + } else { + documentPathBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * 
+       ** document path 
+       *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public Builder addDocumentPath( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Builder builderForValue) { + if (documentPathBuilder_ == null) { + ensureDocumentPathIsMutable(); + documentPath_.add(index, builderForValue.build()); + onChanged(); + } else { + documentPathBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** document path 
+       *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public Builder addAllDocumentPath( + java.lang.Iterable values) { + if (documentPathBuilder_ == null) { + ensureDocumentPathIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, documentPath_); + onChanged(); + } else { + documentPathBuilder_.addAllMessages(values); + } + return this; + } + /** + * 
+       ** document path 
+       *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public Builder clearDocumentPath() { + if (documentPathBuilder_ == null) { + documentPath_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + } else { + documentPathBuilder_.clear(); + } + return this; + } + /** + * 
+       ** document path 
+       *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public Builder removeDocumentPath(int index) { + if (documentPathBuilder_ == null) { + ensureDocumentPathIsMutable(); + documentPath_.remove(index); + onChanged(); + } else { + documentPathBuilder_.remove(index); + } + return this; + } + /** + * 
+       ** document path 
+       *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Builder getDocumentPathBuilder( + int index) { + return getDocumentPathFieldBuilder().getBuilder(index); + } + /** + * 
+       ** document path 
+       *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItemOrBuilder getDocumentPathOrBuilder( + int index) { + if (documentPathBuilder_ == null) { + return documentPath_.get(index); } else { + return documentPathBuilder_.getMessageOrBuilder(index); + } + } + /** + * 
+       ** document path 
+       *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public java.util.List + getDocumentPathOrBuilderList() { + if (documentPathBuilder_ != null) { + return documentPathBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(documentPath_); + } + } + /** + * 
+       ** document path 
+       *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Builder addDocumentPathBuilder() { + return getDocumentPathFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.getDefaultInstance()); + } + /** + * 
+       ** document path 
+       *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Builder addDocumentPathBuilder( + int index) { + return getDocumentPathFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.getDefaultInstance()); + } + /** + * 
+       ** document path 
+       *
+ * + * repeated .Mysqlx.Expr.DocumentPathItem document_path = 1; + */ + public java.util.List + getDocumentPathBuilderList() { + return getDocumentPathFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItemOrBuilder> + getDocumentPathFieldBuilder() { + if (documentPathBuilder_ == null) { + documentPathBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItem.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.DocumentPathItemOrBuilder>( + documentPath_, + ((bitField0_ & 0x00000001) != 0), + getParentForChildren(), + isClean()); + documentPath_ = null; + } + return documentPathBuilder_; + } + + private java.lang.Object name_ = ""; + /** + * 
+       ** name of column 
+       *
+ * + * optional string name = 2; + * @return Whether the name field is set. + */ + public boolean hasName() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** name of column 
+       *
+ * + * optional string name = 2; + * @return The name. + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * 
+       ** name of column 
+       *
+ * + * optional string name = 2; + * @return The bytes for name. + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * 
+       ** name of column 
+       *
+ * + * optional string name = 2; + * @param value The name to set. + * @return This builder for chaining. + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + name_ = value; + onChanged(); + return this; + } + /** + * 
+       ** name of column 
+       *
+ * + * optional string name = 2; + * @return This builder for chaining. + */ + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000002); + name_ = getDefaultInstance().getName(); + onChanged(); + return this; + } + /** + * 
+       ** name of column 
+       *
+ * + * optional string name = 2; + * @param value The bytes for name to set. + * @return This builder for chaining. + */ + public Builder setNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + name_ = value; + onChanged(); + return this; + } + + private java.lang.Object tableName_ = ""; + /** + * 
+       ** name of table 
+       *
+ * + * optional string table_name = 3; + * @return Whether the tableName field is set. + */ + public boolean hasTableName() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+       ** name of table 
+       *
+ * + * optional string table_name = 3; + * @return The tableName. + */ + public java.lang.String getTableName() { + java.lang.Object ref = tableName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + tableName_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * 
+       ** name of table 
+       *
+ * + * optional string table_name = 3; + * @return The bytes for tableName. + */ + public com.google.protobuf.ByteString + getTableNameBytes() { + java.lang.Object ref = tableName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + tableName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * 
+       ** name of table 
+       *
+ * + * optional string table_name = 3; + * @param value The tableName to set. + * @return This builder for chaining. + */ + public Builder setTableName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + tableName_ = value; + onChanged(); + return this; + } + /** + * 
+       ** name of table 
+       *
+ * + * optional string table_name = 3; + * @return This builder for chaining. + */ + public Builder clearTableName() { + bitField0_ = (bitField0_ & ~0x00000004); + tableName_ = getDefaultInstance().getTableName(); + onChanged(); + return this; + } + /** + * 
+       ** name of table 
+       *
+ * + * optional string table_name = 3; + * @param value The bytes for tableName to set. + * @return This builder for chaining. + */ + public Builder setTableNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + tableName_ = value; + onChanged(); + return this; + } + + private java.lang.Object schemaName_ = ""; + /** + * 
+       ** name of schema 
+       *
+ * + * optional string schema_name = 4; + * @return Whether the schemaName field is set. + */ + public boolean hasSchemaName() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * 
+       ** name of schema 
+       *
+ * + * optional string schema_name = 4; + * @return The schemaName. + */ + public java.lang.String getSchemaName() { + java.lang.Object ref = schemaName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + schemaName_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * 
+       ** name of schema 
+       *
+ * + * optional string schema_name = 4; + * @return The bytes for schemaName. + */ + public com.google.protobuf.ByteString + getSchemaNameBytes() { + java.lang.Object ref = schemaName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + schemaName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * 
+       ** name of schema 
+       *
+ * + * optional string schema_name = 4; + * @param value The schemaName to set. + * @return This builder for chaining. + */ + public Builder setSchemaName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + schemaName_ = value; + onChanged(); + return this; + } + /** + * 
+       ** name of schema 
+       *
+ * + * optional string schema_name = 4; + * @return This builder for chaining. + */ + public Builder clearSchemaName() { + bitField0_ = (bitField0_ & ~0x00000008); + schemaName_ = getDefaultInstance().getSchemaName(); + onChanged(); + return this; + } + /** + * 
+       ** name of schema 
+       *
+ * + * optional string schema_name = 4; + * @param value The bytes for schemaName to set. + * @return This builder for chaining. + */ + public Builder setSchemaNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + schemaName_ = value; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Expr.ColumnIdentifier) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Expr.ColumnIdentifier) + private static final com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier(); + } + + public static com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public ColumnIdentifier parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new ColumnIdentifier(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.ColumnIdentifier getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface FunctionCallOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Expr.FunctionCall) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** identifier of function; at least name of it 
+     *
+ * + * required .Mysqlx.Expr.Identifier name = 1; + * @return Whether the name field is set. + */ + boolean hasName(); + /** + * 
+     ** identifier of function; at least name of it 
+     *
+ * + * required .Mysqlx.Expr.Identifier name = 1; + * @return The name. + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Identifier getName(); + /** + * 
+     ** identifier of function; at least name of it 
+     *
+ * + * required .Mysqlx.Expr.Identifier name = 1; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.IdentifierOrBuilder getNameOrBuilder(); + + /** + * 
+     ** list of parameters 
+     *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + java.util.List + getParamList(); + /** + * 
+     ** list of parameters 
+     *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Expr getParam(int index); + /** + * 
+     ** list of parameters 
+     *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + int getParamCount(); + /** + * 
+     ** list of parameters 
+     *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + java.util.List + getParamOrBuilderList(); + /** + * 
+     ** list of parameters 
+     *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getParamOrBuilder( + int index); + } + /** + * 
+   **
+   *Function call: ``func(a, b, "1", 3)``
+   *@par production list
+   *@code{unparsed}
+   *function_call: `identifier` "(" [ `expr` ["," `expr` ]* ] ")"
+   *@endcode
+   *
+ * + * Protobuf type {@code Mysqlx.Expr.FunctionCall} + */ + public static final class FunctionCall extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Expr.FunctionCall) + FunctionCallOrBuilder { + private static final long serialVersionUID = 0L; + // Use FunctionCall.newBuilder() to construct. + private FunctionCall(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private FunctionCall() { + param_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new FunctionCall(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private FunctionCall( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + com.mysql.cj.x.protobuf.MysqlxExpr.Identifier.Builder subBuilder = null; + if (((bitField0_ & 0x00000001) != 0)) { + subBuilder = name_.toBuilder(); + } + name_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.Identifier.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(name_); + name_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000001; + break; + } + case 18: { + if (!((mutable_bitField0_ & 0x00000002) != 0)) { + param_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000002; + } + param_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.Expr.PARSER, extensionRegistry)); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000002) != 0)) { + param_ = java.util.Collections.unmodifiableList(param_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_FunctionCall_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_FunctionCall_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall.class, com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall.Builder.class); + } + + private int bitField0_; + public static final int NAME_FIELD_NUMBER = 1; + private com.mysql.cj.x.protobuf.MysqlxExpr.Identifier name_; + /** + * 
+     ** identifier of function; at least name of it 
+     *
+ * + * required .Mysqlx.Expr.Identifier name = 1; + * @return Whether the name field is set. + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** identifier of function; at least name of it 
+     *
+ * + * required .Mysqlx.Expr.Identifier name = 1; + * @return The name. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Identifier getName() { + return name_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Identifier.getDefaultInstance() : name_; + } + /** + * 
+     ** identifier of function; at least name of it 
+     *
+ * + * required .Mysqlx.Expr.Identifier name = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.IdentifierOrBuilder getNameOrBuilder() { + return name_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Identifier.getDefaultInstance() : name_; + } + + public static final int PARAM_FIELD_NUMBER = 2; + private java.util.List param_; + /** + * 
+     ** list of parameters 
+     *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public java.util.List getParamList() { + return param_; + } + /** + * 
+     ** list of parameters 
+     *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public java.util.List + getParamOrBuilderList() { + return param_; + } + /** + * 
+     ** list of parameters 
+     *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public int getParamCount() { + return param_.size(); + } + /** + * 
+     ** list of parameters 
+     *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getParam(int index) { + return param_.get(index); + } + /** + * 
+     ** list of parameters 
+     *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getParamOrBuilder( + int index) { + return param_.get(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasName()) { + memoizedIsInitialized = 0; + return false; + } + if (!getName().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + for (int i = 0; i < getParamCount(); i++) { + if (!getParam(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeMessage(1, getName()); + } + for (int i = 0; i < param_.size(); i++) { + output.writeMessage(2, param_.get(i)); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, getName()); + } + for (int i = 0; i < param_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, param_.get(i)); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall other = (com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall) obj; + + if (hasName() != other.hasName()) return false; + if (hasName()) { + if (!getName() + .equals(other.getName())) return false; + } + if (!getParamList() + .equals(other.getParamList())) return false; + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasName()) { + hash = (37 * hash) + NAME_FIELD_NUMBER; + hash = (53 * hash) + getName().hashCode(); + } + if (getParamCount() > 0) { + hash = (37 * hash) + PARAM_FIELD_NUMBER; + hash = (53 * hash) + getParamList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Function call: ``func(a, b, "1", 3)``
+     *@par production list
+     *@code{unparsed}
+     *function_call: `identifier` "(" [ `expr` ["," `expr` ]* ] ")"
+     *@endcode
+     *
+ * + * Protobuf type {@code Mysqlx.Expr.FunctionCall} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Expr.FunctionCall) + com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCallOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_FunctionCall_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_FunctionCall_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall.class, com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getNameFieldBuilder(); + getParamFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + if (nameBuilder_ == null) { + name_ = null; + } else { + nameBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + if (paramBuilder_ == null) { + param_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + } else { + paramBuilder_.clear(); + } + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_FunctionCall_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall build() { + com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall buildPartial() { + com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall result = new com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + if (nameBuilder_ == null) { + result.name_ = name_; + } else { + result.name_ = nameBuilder_.build(); + } + to_bitField0_ |= 0x00000001; + } + if (paramBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0)) { + param_ = java.util.Collections.unmodifiableList(param_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.param_ = param_; + } else { + result.param_ = paramBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall other) { + if (other == com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall.getDefaultInstance()) return this; + if (other.hasName()) { + mergeName(other.getName()); + } + if (paramBuilder_ == null) { + if (!other.param_.isEmpty()) { + if (param_.isEmpty()) { + param_ = other.param_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureParamIsMutable(); + param_.addAll(other.param_); + } + onChanged(); + } + } else { + if (!other.param_.isEmpty()) { + if (paramBuilder_.isEmpty()) { + paramBuilder_.dispose(); + paramBuilder_ = null; + param_ = other.param_; + bitField0_ = (bitField0_ & ~0x00000002); + paramBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getParamFieldBuilder() : null; + } else { + paramBuilder_.addAllMessages(other.param_); + } + } + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasName()) { + return false; + } + if (!getName().isInitialized()) { + return false; + } + for (int i = 0; i < getParamCount(); i++) { + if (!getParam(i).isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private com.mysql.cj.x.protobuf.MysqlxExpr.Identifier name_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Identifier, com.mysql.cj.x.protobuf.MysqlxExpr.Identifier.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.IdentifierOrBuilder> nameBuilder_; + /** + * 
+       ** identifier of function; at least name of it 
+       *
+ * + * required .Mysqlx.Expr.Identifier name = 1; + * @return Whether the name field is set. + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** identifier of function; at least name of it 
+       *
+ * + * required .Mysqlx.Expr.Identifier name = 1; + * @return The name. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Identifier getName() { + if (nameBuilder_ == null) { + return name_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Identifier.getDefaultInstance() : name_; + } else { + return nameBuilder_.getMessage(); + } + } + /** + * 
+       ** identifier of function; at least name of it 
+       *
+ * + * required .Mysqlx.Expr.Identifier name = 1; + */ + public Builder setName(com.mysql.cj.x.protobuf.MysqlxExpr.Identifier value) { + if (nameBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + name_ = value; + onChanged(); + } else { + nameBuilder_.setMessage(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** identifier of function; at least name of it 
+       *
+ * + * required .Mysqlx.Expr.Identifier name = 1; + */ + public Builder setName( + com.mysql.cj.x.protobuf.MysqlxExpr.Identifier.Builder builderForValue) { + if (nameBuilder_ == null) { + name_ = builderForValue.build(); + onChanged(); + } else { + nameBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** identifier of function; at least name of it 
+       *
+ * + * required .Mysqlx.Expr.Identifier name = 1; + */ + public Builder mergeName(com.mysql.cj.x.protobuf.MysqlxExpr.Identifier value) { + if (nameBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0) && + name_ != null && + name_ != com.mysql.cj.x.protobuf.MysqlxExpr.Identifier.getDefaultInstance()) { + name_ = + com.mysql.cj.x.protobuf.MysqlxExpr.Identifier.newBuilder(name_).mergeFrom(value).buildPartial(); + } else { + name_ = value; + } + onChanged(); + } else { + nameBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000001; + return this; + } + /** + * 
+       ** identifier of function; at least name of it 
+       *
+ * + * required .Mysqlx.Expr.Identifier name = 1; + */ + public Builder clearName() { + if (nameBuilder_ == null) { + name_ = null; + onChanged(); + } else { + nameBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + /** + * 
+       ** identifier of function; at least name of it 
+       *
+ * + * required .Mysqlx.Expr.Identifier name = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Identifier.Builder getNameBuilder() { + bitField0_ |= 0x00000001; + onChanged(); + return getNameFieldBuilder().getBuilder(); + } + /** + * 
+       ** identifier of function; at least name of it 
+       *
+ * + * required .Mysqlx.Expr.Identifier name = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.IdentifierOrBuilder getNameOrBuilder() { + if (nameBuilder_ != null) { + return nameBuilder_.getMessageOrBuilder(); + } else { + return name_ == null ? + com.mysql.cj.x.protobuf.MysqlxExpr.Identifier.getDefaultInstance() : name_; + } + } + /** + * 
+       ** identifier of function; at least name of it 
+       *
+ * + * required .Mysqlx.Expr.Identifier name = 1; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Identifier, com.mysql.cj.x.protobuf.MysqlxExpr.Identifier.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.IdentifierOrBuilder> + getNameFieldBuilder() { + if (nameBuilder_ == null) { + nameBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Identifier, com.mysql.cj.x.protobuf.MysqlxExpr.Identifier.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.IdentifierOrBuilder>( + getName(), + getParentForChildren(), + isClean()); + name_ = null; + } + return nameBuilder_; + } + + private java.util.List param_ = + java.util.Collections.emptyList(); + private void ensureParamIsMutable() { + if (!((bitField0_ & 0x00000002) != 0)) { + param_ = new java.util.ArrayList(param_); + bitField0_ |= 0x00000002; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> paramBuilder_; + + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public java.util.List getParamList() { + if (paramBuilder_ == null) { + return java.util.Collections.unmodifiableList(param_); + } else { + return paramBuilder_.getMessageList(); + } + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public int getParamCount() { + if (paramBuilder_ == null) { + return param_.size(); + } else { + return paramBuilder_.getCount(); + } + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getParam(int index) { + if (paramBuilder_ == null) { + return param_.get(index); + } else { + return paramBuilder_.getMessage(index); + } + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public Builder setParam( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (paramBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureParamIsMutable(); + param_.set(index, value); + onChanged(); + } else { + paramBuilder_.setMessage(index, value); + } + return this; + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public Builder setParam( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (paramBuilder_ == null) { + ensureParamIsMutable(); + param_.set(index, builderForValue.build()); + onChanged(); + } else { + paramBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public Builder addParam(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (paramBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureParamIsMutable(); + param_.add(value); + onChanged(); + } else { + paramBuilder_.addMessage(value); + } + return this; + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public Builder addParam( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (paramBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureParamIsMutable(); + param_.add(index, value); + onChanged(); + } else { + paramBuilder_.addMessage(index, value); + } + return this; + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public Builder addParam( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (paramBuilder_ == null) { + ensureParamIsMutable(); + param_.add(builderForValue.build()); + onChanged(); + } else { + paramBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public Builder addParam( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (paramBuilder_ == null) { + ensureParamIsMutable(); + param_.add(index, builderForValue.build()); + onChanged(); + } else { + paramBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public Builder addAllParam( + java.lang.Iterable values) { + if (paramBuilder_ == null) { + ensureParamIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, param_); + onChanged(); + } else { + paramBuilder_.addAllMessages(values); + } + return this; + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public Builder clearParam() { + if (paramBuilder_ == null) { + param_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + } else { + paramBuilder_.clear(); + } + return this; + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public Builder removeParam(int index) { + if (paramBuilder_ == null) { + ensureParamIsMutable(); + param_.remove(index); + onChanged(); + } else { + paramBuilder_.remove(index); + } + return this; + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder getParamBuilder( + int index) { + return getParamFieldBuilder().getBuilder(index); + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getParamOrBuilder( + int index) { + if (paramBuilder_ == null) { + return param_.get(index); } else { + return paramBuilder_.getMessageOrBuilder(index); + } + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public java.util.List + getParamOrBuilderList() { + if (paramBuilder_ != null) { + return paramBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(param_); + } + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder addParamBuilder() { + return getParamFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance()); + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder addParamBuilder( + int index) { + return getParamFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance()); + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public java.util.List + getParamBuilderList() { + return getParamFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> + getParamFieldBuilder() { + if (paramBuilder_ == null) { + paramBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder>( + param_, + ((bitField0_ & 0x00000002) != 0), + getParentForChildren(), + isClean()); + param_ = null; + } + return paramBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Expr.FunctionCall) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Expr.FunctionCall) + private static final com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall(); + } + + public static com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public FunctionCall parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new FunctionCall(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.FunctionCall getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface OperatorOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Expr.Operator) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** name of operator 
+     *
+ * + * required string name = 1; + * @return Whether the name field is set. + */ + boolean hasName(); + /** + * 
+     ** name of operator 
+     *
+ * + * required string name = 1; + * @return The name. + */ + java.lang.String getName(); + /** + * 
+     ** name of operator 
+     *
+ * + * required string name = 1; + * @return The bytes for name. + */ + com.google.protobuf.ByteString + getNameBytes(); + + /** + * 
+     ** list of parameters 
+     *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + java.util.List + getParamList(); + /** + * 
+     ** list of parameters 
+     *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Expr getParam(int index); + /** + * 
+     ** list of parameters 
+     *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + int getParamCount(); + /** + * 
+     ** list of parameters 
+     *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + java.util.List + getParamOrBuilderList(); + /** + * 
+     ** list of parameters 
+     *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getParamOrBuilder( + int index); + } + /** + * Protobuf type {@code Mysqlx.Expr.Operator} + */ + public static final class Operator extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Expr.Operator) + OperatorOrBuilder { + private static final long serialVersionUID = 0L; + // Use Operator.newBuilder() to construct. + private Operator(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Operator() { + name_ = ""; + param_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Operator(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Operator( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000001; + name_ = bs; + break; + } + case 18: { + if (!((mutable_bitField0_ & 0x00000002) != 0)) { + param_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000002; + } + param_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.Expr.PARSER, extensionRegistry)); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000002) != 0)) { + param_ = java.util.Collections.unmodifiableList(param_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Operator_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Operator_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpr.Operator.class, com.mysql.cj.x.protobuf.MysqlxExpr.Operator.Builder.class); + } + + private int bitField0_; + public static final int NAME_FIELD_NUMBER = 1; + private volatile java.lang.Object name_; + /** + * 
+     ** name of operator 
+     *
+ * + * required string name = 1; + * @return Whether the name field is set. + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** name of operator 
+     *
+ * + * required string name = 1; + * @return The name. + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } + } + /** + * 
+     ** name of operator 
+     *
+ * + * required string name = 1; + * @return The bytes for name. + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int PARAM_FIELD_NUMBER = 2; + private java.util.List param_; + /** + * 
+     ** list of parameters 
+     *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public java.util.List getParamList() { + return param_; + } + /** + * 
+     ** list of parameters 
+     *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public java.util.List + getParamOrBuilderList() { + return param_; + } + /** + * 
+     ** list of parameters 
+     *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public int getParamCount() { + return param_.size(); + } + /** + * 
+     ** list of parameters 
+     *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getParam(int index) { + return param_.get(index); + } + /** + * 
+     ** list of parameters 
+     *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getParamOrBuilder( + int index) { + return param_.get(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasName()) { + memoizedIsInitialized = 0; + return false; + } + for (int i = 0; i < getParamCount(); i++) { + if (!getParam(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, name_); + } + for (int i = 0; i < param_.size(); i++) { + output.writeMessage(2, param_.get(i)); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, name_); + } + for (int i = 0; i < param_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, param_.get(i)); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxExpr.Operator)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxExpr.Operator other = (com.mysql.cj.x.protobuf.MysqlxExpr.Operator) obj; + + if (hasName() != other.hasName()) return false; + if (hasName()) { + if (!getName() + .equals(other.getName())) return false; + } + if (!getParamList() + .equals(other.getParamList())) return false; + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasName()) { + hash = (37 * hash) + NAME_FIELD_NUMBER; + hash = (53 * hash) + getName().hashCode(); + } + if (getParamCount() > 0) { + hash = (37 * hash) + PARAM_FIELD_NUMBER; + hash = (53 * hash) + getParamList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxExpr.Operator parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Operator parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Operator parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Operator parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Operator parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Operator parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Operator parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Operator parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Operator parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Operator parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Operator parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Operator parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxExpr.Operator prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Mysqlx.Expr.Operator} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Expr.Operator) + com.mysql.cj.x.protobuf.MysqlxExpr.OperatorOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Operator_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Operator_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpr.Operator.class, com.mysql.cj.x.protobuf.MysqlxExpr.Operator.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxExpr.Operator.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getParamFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + name_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + if (paramBuilder_ == null) { + param_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + } else { + paramBuilder_.clear(); + } + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Operator_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Operator getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxExpr.Operator.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Operator build() { + com.mysql.cj.x.protobuf.MysqlxExpr.Operator result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Operator buildPartial() { + com.mysql.cj.x.protobuf.MysqlxExpr.Operator result = new com.mysql.cj.x.protobuf.MysqlxExpr.Operator(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.name_ = name_; + if (paramBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0)) { + param_ = java.util.Collections.unmodifiableList(param_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.param_ = param_; + } else { + result.param_ = paramBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxExpr.Operator) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxExpr.Operator)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxExpr.Operator other) { + if (other == com.mysql.cj.x.protobuf.MysqlxExpr.Operator.getDefaultInstance()) return this; + if (other.hasName()) { + bitField0_ |= 0x00000001; + name_ = other.name_; + onChanged(); + } + if (paramBuilder_ == null) { + if (!other.param_.isEmpty()) { + if (param_.isEmpty()) { + param_ = other.param_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureParamIsMutable(); + param_.addAll(other.param_); + } + onChanged(); + } + } else { + if (!other.param_.isEmpty()) { + if (paramBuilder_.isEmpty()) { + paramBuilder_.dispose(); + paramBuilder_ = null; + param_ = other.param_; + bitField0_ = (bitField0_ & ~0x00000002); + paramBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getParamFieldBuilder() : null; + } else { + paramBuilder_.addAllMessages(other.param_); + } + } + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasName()) { + return false; + } + for (int i = 0; i < getParamCount(); i++) { + if (!getParam(i).isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxExpr.Operator parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxExpr.Operator) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object name_ = ""; + /** + * 
+       ** name of operator 
+       *
+ * + * required string name = 1; + * @return Whether the name field is set. + */ + public boolean hasName() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** name of operator 
+       *
+ * + * required string name = 1; + * @return The name. + */ + public java.lang.String getName() { + java.lang.Object ref = name_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + name_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * 
+       ** name of operator 
+       *
+ * + * required string name = 1; + * @return The bytes for name. + */ + public com.google.protobuf.ByteString + getNameBytes() { + java.lang.Object ref = name_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + name_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * 
+       ** name of operator 
+       *
+ * + * required string name = 1; + * @param value The name to set. + * @return This builder for chaining. + */ + public Builder setName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + name_ = value; + onChanged(); + return this; + } + /** + * 
+       ** name of operator 
+       *
+ * + * required string name = 1; + * @return This builder for chaining. + */ + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000001); + name_ = getDefaultInstance().getName(); + onChanged(); + return this; + } + /** + * 
+       ** name of operator 
+       *
+ * + * required string name = 1; + * @param value The bytes for name to set. + * @return This builder for chaining. + */ + public Builder setNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + name_ = value; + onChanged(); + return this; + } + + private java.util.List param_ = + java.util.Collections.emptyList(); + private void ensureParamIsMutable() { + if (!((bitField0_ & 0x00000002) != 0)) { + param_ = new java.util.ArrayList(param_); + bitField0_ |= 0x00000002; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> paramBuilder_; + + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public java.util.List getParamList() { + if (paramBuilder_ == null) { + return java.util.Collections.unmodifiableList(param_); + } else { + return paramBuilder_.getMessageList(); + } + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public int getParamCount() { + if (paramBuilder_ == null) { + return param_.size(); + } else { + return paramBuilder_.getCount(); + } + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getParam(int index) { + if (paramBuilder_ == null) { + return param_.get(index); + } else { + return paramBuilder_.getMessage(index); + } + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public Builder setParam( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (paramBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureParamIsMutable(); + param_.set(index, value); + onChanged(); + } else { + paramBuilder_.setMessage(index, value); + } + return this; + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public Builder setParam( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (paramBuilder_ == null) { + ensureParamIsMutable(); + param_.set(index, builderForValue.build()); + onChanged(); + } else { + paramBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public Builder addParam(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (paramBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureParamIsMutable(); + param_.add(value); + onChanged(); + } else { + paramBuilder_.addMessage(value); + } + return this; + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public Builder addParam( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (paramBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureParamIsMutable(); + param_.add(index, value); + onChanged(); + } else { + paramBuilder_.addMessage(index, value); + } + return this; + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public Builder addParam( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (paramBuilder_ == null) { + ensureParamIsMutable(); + param_.add(builderForValue.build()); + onChanged(); + } else { + paramBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public Builder addParam( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (paramBuilder_ == null) { + ensureParamIsMutable(); + param_.add(index, builderForValue.build()); + onChanged(); + } else { + paramBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public Builder addAllParam( + java.lang.Iterable values) { + if (paramBuilder_ == null) { + ensureParamIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, param_); + onChanged(); + } else { + paramBuilder_.addAllMessages(values); + } + return this; + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public Builder clearParam() { + if (paramBuilder_ == null) { + param_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + } else { + paramBuilder_.clear(); + } + return this; + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public Builder removeParam(int index) { + if (paramBuilder_ == null) { + ensureParamIsMutable(); + param_.remove(index); + onChanged(); + } else { + paramBuilder_.remove(index); + } + return this; + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder getParamBuilder( + int index) { + return getParamFieldBuilder().getBuilder(index); + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getParamOrBuilder( + int index) { + if (paramBuilder_ == null) { + return param_.get(index); } else { + return paramBuilder_.getMessageOrBuilder(index); + } + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public java.util.List + getParamOrBuilderList() { + if (paramBuilder_ != null) { + return paramBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(param_); + } + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder addParamBuilder() { + return getParamFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance()); + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder addParamBuilder( + int index) { + return getParamFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance()); + } + /** + * 
+       ** list of parameters 
+       *
+ * + * repeated .Mysqlx.Expr.Expr param = 2; + */ + public java.util.List + getParamBuilderList() { + return getParamFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> + getParamFieldBuilder() { + if (paramBuilder_ == null) { + paramBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder>( + param_, + ((bitField0_ & 0x00000002) != 0), + getParentForChildren(), + isClean()); + param_ = null; + } + return paramBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Expr.Operator) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Expr.Operator) + private static final com.mysql.cj.x.protobuf.MysqlxExpr.Operator DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxExpr.Operator(); + } + + public static com.mysql.cj.x.protobuf.MysqlxExpr.Operator getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Operator parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Operator(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Operator getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ObjectOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Expr.Object) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** list of fields 
+     *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + java.util.List + getFldList(); + /** + * 
+     ** list of fields 
+     *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField getFld(int index); + /** + * 
+     ** list of fields 
+     *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + int getFldCount(); + /** + * 
+     ** list of fields 
+     *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + java.util.List + getFldOrBuilderList(); + /** + * 
+     ** list of fields 
+     *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectFieldOrBuilder getFldOrBuilder( + int index); + } + /** + * 
+   **
+   *An object (with expression values)
+   *
+ * + * Protobuf type {@code Mysqlx.Expr.Object} + */ + public static final class Object extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Expr.Object) + ObjectOrBuilder { + private static final long serialVersionUID = 0L; + // Use Object.newBuilder() to construct. + private Object(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Object() { + fld_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Object(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Object( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + if (!((mutable_bitField0_ & 0x00000001) != 0)) { + fld_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + fld_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField.PARSER, extensionRegistry)); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000001) != 0)) { + fld_ = java.util.Collections.unmodifiableList(fld_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Object_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Object_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpr.Object.class, com.mysql.cj.x.protobuf.MysqlxExpr.Object.Builder.class); + } + + public interface ObjectFieldOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Expr.Object.ObjectField) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+       ** identifier of field 
+       *
+ * + * required string key = 1; + * @return Whether the key field is set. + */ + boolean hasKey(); + /** + * 
+       ** identifier of field 
+       *
+ * + * required string key = 1; + * @return The key. + */ + java.lang.String getKey(); + /** + * 
+       ** identifier of field 
+       *
+ * + * required string key = 1; + * @return The bytes for key. + */ + com.google.protobuf.ByteString + getKeyBytes(); + + /** + * 
+       ** value of field 
+       *
+ * + * required .Mysqlx.Expr.Expr value = 2; + * @return Whether the value field is set. + */ + boolean hasValue(); + /** + * 
+       ** value of field 
+       *
+ * + * required .Mysqlx.Expr.Expr value = 2; + * @return The value. + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Expr getValue(); + /** + * 
+       ** value of field 
+       *
+ * + * required .Mysqlx.Expr.Expr value = 2; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getValueOrBuilder(); + } + /** + * Protobuf type {@code Mysqlx.Expr.Object.ObjectField} + */ + public static final class ObjectField extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Expr.Object.ObjectField) + ObjectFieldOrBuilder { + private static final long serialVersionUID = 0L; + // Use ObjectField.newBuilder() to construct. + private ObjectField(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private ObjectField() { + key_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new ObjectField(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private ObjectField( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000001; + key_ = bs; + break; + } + case 18: { + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) != 0)) { + subBuilder = value_.toBuilder(); + } + value_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.Expr.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(value_); + value_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Object_ObjectField_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Object_ObjectField_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField.class, com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField.Builder.class); + } + + private int bitField0_; + public static final int KEY_FIELD_NUMBER = 1; + private volatile java.lang.Object key_; + /** + * 
+       ** identifier of field 
+       *
+ * + * required string key = 1; + * @return Whether the key field is set. + */ + public boolean hasKey() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** identifier of field 
+       *
+ * + * required string key = 1; + * @return The key. + */ + public java.lang.String getKey() { + java.lang.Object ref = key_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + key_ = s; + } + return s; + } + } + /** + * 
+       ** identifier of field 
+       *
+ * + * required string key = 1; + * @return The bytes for key. + */ + public com.google.protobuf.ByteString + getKeyBytes() { + java.lang.Object ref = key_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + key_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int VALUE_FIELD_NUMBER = 2; + private com.mysql.cj.x.protobuf.MysqlxExpr.Expr value_; + /** + * 
+       ** value of field 
+       *
+ * + * required .Mysqlx.Expr.Expr value = 2; + * @return Whether the value field is set. + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** value of field 
+       *
+ * + * required .Mysqlx.Expr.Expr value = 2; + * @return The value. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getValue() { + return value_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : value_; + } + /** + * 
+       ** value of field 
+       *
+ * + * required .Mysqlx.Expr.Expr value = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getValueOrBuilder() { + return value_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : value_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasKey()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasValue()) { + memoizedIsInitialized = 0; + return false; + } + if (!getValue().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, key_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeMessage(2, getValue()); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, key_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, getValue()); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField other = (com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField) obj; + + if (hasKey() != other.hasKey()) return false; + if (hasKey()) { + if (!getKey() + .equals(other.getKey())) return false; + } + if (hasValue() != other.hasValue()) return false; + if (hasValue()) { + if (!getValue() + .equals(other.getValue())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasKey()) { + hash = (37 * hash) + KEY_FIELD_NUMBER; + hash = (53 * hash) + getKey().hashCode(); + } + if (hasValue()) { + hash = (37 * hash) + VALUE_FIELD_NUMBER; + hash = (53 * hash) + getValue().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Mysqlx.Expr.Object.ObjectField} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Expr.Object.ObjectField) + com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectFieldOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Object_ObjectField_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Object_ObjectField_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField.class, com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getValueFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + key_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + if (valueBuilder_ == null) { + value_ = null; + } else { + valueBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Object_ObjectField_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField build() { + com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField buildPartial() { + com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField result = new com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.key_ = key_; + if (((from_bitField0_ & 0x00000002) != 0)) { + if (valueBuilder_ == null) { + result.value_ = value_; + } else { + result.value_ = valueBuilder_.build(); + } + to_bitField0_ |= 0x00000002; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField other) { + if (other == com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField.getDefaultInstance()) return this; + if (other.hasKey()) { + bitField0_ |= 0x00000001; + key_ = other.key_; + onChanged(); + } + if (other.hasValue()) { + mergeValue(other.getValue()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasKey()) { + return false; + } + if (!hasValue()) { + return false; + } + if (!getValue().isInitialized()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object key_ = ""; + /** + * 
+         ** identifier of field 
+         *
+ * + * required string key = 1; + * @return Whether the key field is set. + */ + public boolean hasKey() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+         ** identifier of field 
+         *
+ * + * required string key = 1; + * @return The key. + */ + public java.lang.String getKey() { + java.lang.Object ref = key_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + key_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * 
+         ** identifier of field 
+         *
+ * + * required string key = 1; + * @return The bytes for key. + */ + public com.google.protobuf.ByteString + getKeyBytes() { + java.lang.Object ref = key_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + key_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * 
+         ** identifier of field 
+         *
+ * + * required string key = 1; + * @param value The key to set. + * @return This builder for chaining. + */ + public Builder setKey( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + key_ = value; + onChanged(); + return this; + } + /** + * 
+         ** identifier of field 
+         *
+ * + * required string key = 1; + * @return This builder for chaining. + */ + public Builder clearKey() { + bitField0_ = (bitField0_ & ~0x00000001); + key_ = getDefaultInstance().getKey(); + onChanged(); + return this; + } + /** + * 
+         ** identifier of field 
+         *
+ * + * required string key = 1; + * @param value The bytes for key to set. + * @return This builder for chaining. + */ + public Builder setKeyBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + key_ = value; + onChanged(); + return this; + } + + private com.mysql.cj.x.protobuf.MysqlxExpr.Expr value_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> valueBuilder_; + /** + * 
+         ** value of field 
+         *
+ * + * required .Mysqlx.Expr.Expr value = 2; + * @return Whether the value field is set. + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+         ** value of field 
+         *
+ * + * required .Mysqlx.Expr.Expr value = 2; + * @return The value. + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getValue() { + if (valueBuilder_ == null) { + return value_ == null ? com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : value_; + } else { + return valueBuilder_.getMessage(); + } + } + /** + * 
+         ** value of field 
+         *
+ * + * required .Mysqlx.Expr.Expr value = 2; + */ + public Builder setValue(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (valueBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + value_ = value; + onChanged(); + } else { + valueBuilder_.setMessage(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * 
+         ** value of field 
+         *
+ * + * required .Mysqlx.Expr.Expr value = 2; + */ + public Builder setValue( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (valueBuilder_ == null) { + value_ = builderForValue.build(); + onChanged(); + } else { + valueBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * 
+         ** value of field 
+         *
+ * + * required .Mysqlx.Expr.Expr value = 2; + */ + public Builder mergeValue(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (valueBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0) && + value_ != null && + value_ != com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance()) { + value_ = + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.newBuilder(value_).mergeFrom(value).buildPartial(); + } else { + value_ = value; + } + onChanged(); + } else { + valueBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * 
+         ** value of field 
+         *
+ * + * required .Mysqlx.Expr.Expr value = 2; + */ + public Builder clearValue() { + if (valueBuilder_ == null) { + value_ = null; + onChanged(); + } else { + valueBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + /** + * 
+         ** value of field 
+         *
+ * + * required .Mysqlx.Expr.Expr value = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder getValueBuilder() { + bitField0_ |= 0x00000002; + onChanged(); + return getValueFieldBuilder().getBuilder(); + } + /** + * 
+         ** value of field 
+         *
+ * + * required .Mysqlx.Expr.Expr value = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getValueOrBuilder() { + if (valueBuilder_ != null) { + return valueBuilder_.getMessageOrBuilder(); + } else { + return value_ == null ? + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance() : value_; + } + } + /** + * 
+         ** value of field 
+         *
+ * + * required .Mysqlx.Expr.Expr value = 2; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> + getValueFieldBuilder() { + if (valueBuilder_ == null) { + valueBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder>( + getValue(), + getParentForChildren(), + isClean()); + value_ = null; + } + return valueBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Expr.Object.ObjectField) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Expr.Object.ObjectField) + private static final com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField(); + } + + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public ObjectField parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new ObjectField(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public static final int FLD_FIELD_NUMBER = 1; + private java.util.List fld_; + /** + * 
+     ** list of fields 
+     *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public java.util.List getFldList() { + return fld_; + } + /** + * 
+     ** list of fields 
+     *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public java.util.List + getFldOrBuilderList() { + return fld_; + } + /** + * 
+     ** list of fields 
+     *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public int getFldCount() { + return fld_.size(); + } + /** + * 
+     ** list of fields 
+     *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField getFld(int index) { + return fld_.get(index); + } + /** + * 
+     ** list of fields 
+     *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectFieldOrBuilder getFldOrBuilder( + int index) { + return fld_.get(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + for (int i = 0; i < getFldCount(); i++) { + if (!getFld(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < fld_.size(); i++) { + output.writeMessage(1, fld_.get(i)); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < fld_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, fld_.get(i)); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxExpr.Object)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxExpr.Object other = (com.mysql.cj.x.protobuf.MysqlxExpr.Object) obj; + + if (!getFldList() + .equals(other.getFldList())) return false; + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getFldCount() > 0) { + hash = (37 * hash) + FLD_FIELD_NUMBER; + hash = (53 * hash) + getFldList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxExpr.Object prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *An object (with expression values)
+     *
+ * + * Protobuf type {@code Mysqlx.Expr.Object} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Expr.Object) + com.mysql.cj.x.protobuf.MysqlxExpr.ObjectOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Object_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Object_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpr.Object.class, com.mysql.cj.x.protobuf.MysqlxExpr.Object.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxExpr.Object.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getFldFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + if (fldBuilder_ == null) { + fld_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + } else { + fldBuilder_.clear(); + } + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Object_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Object getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxExpr.Object.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Object build() { + com.mysql.cj.x.protobuf.MysqlxExpr.Object result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Object buildPartial() { + com.mysql.cj.x.protobuf.MysqlxExpr.Object result = new com.mysql.cj.x.protobuf.MysqlxExpr.Object(this); + int from_bitField0_ = bitField0_; + if (fldBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0)) { + fld_ = java.util.Collections.unmodifiableList(fld_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.fld_ = fld_; + } else { + result.fld_ = fldBuilder_.build(); + } + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxExpr.Object) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxExpr.Object)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxExpr.Object other) { + if (other == com.mysql.cj.x.protobuf.MysqlxExpr.Object.getDefaultInstance()) return this; + if (fldBuilder_ == null) { + if (!other.fld_.isEmpty()) { + if (fld_.isEmpty()) { + fld_ = other.fld_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureFldIsMutable(); + fld_.addAll(other.fld_); + } + onChanged(); + } + } else { + if (!other.fld_.isEmpty()) { + if (fldBuilder_.isEmpty()) { + fldBuilder_.dispose(); + fldBuilder_ = null; + fld_ = other.fld_; + bitField0_ = (bitField0_ & ~0x00000001); + fldBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getFldFieldBuilder() : null; + } else { + fldBuilder_.addAllMessages(other.fld_); + } + } + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + for (int i = 0; i < getFldCount(); i++) { + if (!getFld(i).isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxExpr.Object parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxExpr.Object) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List fld_ = + java.util.Collections.emptyList(); + private void ensureFldIsMutable() { + if (!((bitField0_ & 0x00000001) != 0)) { + fld_ = new java.util.ArrayList(fld_); + bitField0_ |= 0x00000001; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField, com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectFieldOrBuilder> fldBuilder_; + + /** + * 
+       ** list of fields 
+       *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public java.util.List getFldList() { + if (fldBuilder_ == null) { + return java.util.Collections.unmodifiableList(fld_); + } else { + return fldBuilder_.getMessageList(); + } + } + /** + * 
+       ** list of fields 
+       *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public int getFldCount() { + if (fldBuilder_ == null) { + return fld_.size(); + } else { + return fldBuilder_.getCount(); + } + } + /** + * 
+       ** list of fields 
+       *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField getFld(int index) { + if (fldBuilder_ == null) { + return fld_.get(index); + } else { + return fldBuilder_.getMessage(index); + } + } + /** + * 
+       ** list of fields 
+       *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public Builder setFld( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField value) { + if (fldBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureFldIsMutable(); + fld_.set(index, value); + onChanged(); + } else { + fldBuilder_.setMessage(index, value); + } + return this; + } + /** + * 
+       ** list of fields 
+       *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public Builder setFld( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField.Builder builderForValue) { + if (fldBuilder_ == null) { + ensureFldIsMutable(); + fld_.set(index, builderForValue.build()); + onChanged(); + } else { + fldBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** list of fields 
+       *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public Builder addFld(com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField value) { + if (fldBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureFldIsMutable(); + fld_.add(value); + onChanged(); + } else { + fldBuilder_.addMessage(value); + } + return this; + } + /** + * 
+       ** list of fields 
+       *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public Builder addFld( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField value) { + if (fldBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureFldIsMutable(); + fld_.add(index, value); + onChanged(); + } else { + fldBuilder_.addMessage(index, value); + } + return this; + } + /** + * 
+       ** list of fields 
+       *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public Builder addFld( + com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField.Builder builderForValue) { + if (fldBuilder_ == null) { + ensureFldIsMutable(); + fld_.add(builderForValue.build()); + onChanged(); + } else { + fldBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * 
+       ** list of fields 
+       *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public Builder addFld( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField.Builder builderForValue) { + if (fldBuilder_ == null) { + ensureFldIsMutable(); + fld_.add(index, builderForValue.build()); + onChanged(); + } else { + fldBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** list of fields 
+       *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public Builder addAllFld( + java.lang.Iterable values) { + if (fldBuilder_ == null) { + ensureFldIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, fld_); + onChanged(); + } else { + fldBuilder_.addAllMessages(values); + } + return this; + } + /** + * 
+       ** list of fields 
+       *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public Builder clearFld() { + if (fldBuilder_ == null) { + fld_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + } else { + fldBuilder_.clear(); + } + return this; + } + /** + * 
+       ** list of fields 
+       *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public Builder removeFld(int index) { + if (fldBuilder_ == null) { + ensureFldIsMutable(); + fld_.remove(index); + onChanged(); + } else { + fldBuilder_.remove(index); + } + return this; + } + /** + * 
+       ** list of fields 
+       *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField.Builder getFldBuilder( + int index) { + return getFldFieldBuilder().getBuilder(index); + } + /** + * 
+       ** list of fields 
+       *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectFieldOrBuilder getFldOrBuilder( + int index) { + if (fldBuilder_ == null) { + return fld_.get(index); } else { + return fldBuilder_.getMessageOrBuilder(index); + } + } + /** + * 
+       ** list of fields 
+       *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public java.util.List + getFldOrBuilderList() { + if (fldBuilder_ != null) { + return fldBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(fld_); + } + } + /** + * 
+       ** list of fields 
+       *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField.Builder addFldBuilder() { + return getFldFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField.getDefaultInstance()); + } + /** + * 
+       ** list of fields 
+       *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField.Builder addFldBuilder( + int index) { + return getFldFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField.getDefaultInstance()); + } + /** + * 
+       ** list of fields 
+       *
+ * + * repeated .Mysqlx.Expr.Object.ObjectField fld = 1; + */ + public java.util.List + getFldBuilderList() { + return getFldFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField, com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectFieldOrBuilder> + getFldFieldBuilder() { + if (fldBuilder_ == null) { + fldBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField, com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectField.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.Object.ObjectFieldOrBuilder>( + fld_, + ((bitField0_ & 0x00000001) != 0), + getParentForChildren(), + isClean()); + fld_ = null; + } + return fldBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Expr.Object) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Expr.Object) + private static final com.mysql.cj.x.protobuf.MysqlxExpr.Object DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxExpr.Object(); + } + + public static com.mysql.cj.x.protobuf.MysqlxExpr.Object getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Object parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Object(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Object getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ArrayOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Expr.Array) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** list of values 
+     *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + java.util.List + getValueList(); + /** + * 
+     ** list of values 
+     *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.Expr getValue(int index); + /** + * 
+     ** list of values 
+     *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + int getValueCount(); + /** + * 
+     ** list of values 
+     *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + java.util.List + getValueOrBuilderList(); + /** + * 
+     ** list of values 
+     *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getValueOrBuilder( + int index); + } + /** + * 
+   **
+   *An array of expressions
+   *
+ * + * Protobuf type {@code Mysqlx.Expr.Array} + */ + public static final class Array extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Expr.Array) + ArrayOrBuilder { + private static final long serialVersionUID = 0L; + // Use Array.newBuilder() to construct. + private Array(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Array() { + value_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Array(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Array( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + if (!((mutable_bitField0_ & 0x00000001) != 0)) { + value_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + value_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxExpr.Expr.PARSER, extensionRegistry)); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000001) != 0)) { + value_ = java.util.Collections.unmodifiableList(value_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Array_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Array_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpr.Array.class, com.mysql.cj.x.protobuf.MysqlxExpr.Array.Builder.class); + } + + public static final int VALUE_FIELD_NUMBER = 1; + private java.util.List value_; + /** + * 
+     ** list of values 
+     *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public java.util.List getValueList() { + return value_; + } + /** + * 
+     ** list of values 
+     *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public java.util.List + getValueOrBuilderList() { + return value_; + } + /** + * 
+     ** list of values 
+     *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public int getValueCount() { + return value_.size(); + } + /** + * 
+     ** list of values 
+     *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getValue(int index) { + return value_.get(index); + } + /** + * 
+     ** list of values 
+     *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getValueOrBuilder( + int index) { + return value_.get(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + for (int i = 0; i < getValueCount(); i++) { + if (!getValue(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < value_.size(); i++) { + output.writeMessage(1, value_.get(i)); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + for (int i = 0; i < value_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(1, value_.get(i)); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxExpr.Array)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxExpr.Array other = (com.mysql.cj.x.protobuf.MysqlxExpr.Array) obj; + + if (!getValueList() + .equals(other.getValueList())) return false; + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getValueCount() > 0) { + hash = (37 * hash) + VALUE_FIELD_NUMBER; + hash = (53 * hash) + getValueList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxExpr.Array parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Array parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Array parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Array parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Array parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Array parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Array parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Array parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Array parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Array parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Array parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxExpr.Array parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxExpr.Array prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *An array of expressions
+     *
+ * + * Protobuf type {@code Mysqlx.Expr.Array} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Expr.Array) + com.mysql.cj.x.protobuf.MysqlxExpr.ArrayOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Array_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Array_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxExpr.Array.class, com.mysql.cj.x.protobuf.MysqlxExpr.Array.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxExpr.Array.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getValueFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + if (valueBuilder_ == null) { + value_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + } else { + valueBuilder_.clear(); + } + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxExpr.internal_static_Mysqlx_Expr_Array_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Array getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxExpr.Array.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Array build() { + com.mysql.cj.x.protobuf.MysqlxExpr.Array result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Array buildPartial() { + com.mysql.cj.x.protobuf.MysqlxExpr.Array result = new com.mysql.cj.x.protobuf.MysqlxExpr.Array(this); + int from_bitField0_ = bitField0_; + if (valueBuilder_ == null) { + if (((bitField0_ & 0x00000001) != 0)) { + value_ = java.util.Collections.unmodifiableList(value_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.value_ = value_; + } else { + result.value_ = valueBuilder_.build(); + } + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxExpr.Array) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxExpr.Array)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxExpr.Array other) { + if (other == com.mysql.cj.x.protobuf.MysqlxExpr.Array.getDefaultInstance()) return this; + if (valueBuilder_ == null) { + if (!other.value_.isEmpty()) { + if (value_.isEmpty()) { + value_ = other.value_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureValueIsMutable(); + value_.addAll(other.value_); + } + onChanged(); + } + } else { + if (!other.value_.isEmpty()) { + if (valueBuilder_.isEmpty()) { + valueBuilder_.dispose(); + valueBuilder_ = null; + value_ = other.value_; + bitField0_ = (bitField0_ & ~0x00000001); + valueBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getValueFieldBuilder() : null; + } else { + valueBuilder_.addAllMessages(other.value_); + } + } + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + for (int i = 0; i < getValueCount(); i++) { + if (!getValue(i).isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxExpr.Array parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxExpr.Array) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List value_ = + java.util.Collections.emptyList(); + private void ensureValueIsMutable() { + if (!((bitField0_ & 0x00000001) != 0)) { + value_ = new java.util.ArrayList(value_); + bitField0_ |= 0x00000001; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> valueBuilder_; + + /** + * 
+       ** list of values 
+       *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public java.util.List getValueList() { + if (valueBuilder_ == null) { + return java.util.Collections.unmodifiableList(value_); + } else { + return valueBuilder_.getMessageList(); + } + } + /** + * 
+       ** list of values 
+       *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public int getValueCount() { + if (valueBuilder_ == null) { + return value_.size(); + } else { + return valueBuilder_.getCount(); + } + } + /** + * 
+       ** list of values 
+       *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr getValue(int index) { + if (valueBuilder_ == null) { + return value_.get(index); + } else { + return valueBuilder_.getMessage(index); + } + } + /** + * 
+       ** list of values 
+       *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public Builder setValue( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (valueBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureValueIsMutable(); + value_.set(index, value); + onChanged(); + } else { + valueBuilder_.setMessage(index, value); + } + return this; + } + /** + * 
+       ** list of values 
+       *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public Builder setValue( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (valueBuilder_ == null) { + ensureValueIsMutable(); + value_.set(index, builderForValue.build()); + onChanged(); + } else { + valueBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** list of values 
+       *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public Builder addValue(com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (valueBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureValueIsMutable(); + value_.add(value); + onChanged(); + } else { + valueBuilder_.addMessage(value); + } + return this; + } + /** + * 
+       ** list of values 
+       *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public Builder addValue( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr value) { + if (valueBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureValueIsMutable(); + value_.add(index, value); + onChanged(); + } else { + valueBuilder_.addMessage(index, value); + } + return this; + } + /** + * 
+       ** list of values 
+       *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public Builder addValue( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (valueBuilder_ == null) { + ensureValueIsMutable(); + value_.add(builderForValue.build()); + onChanged(); + } else { + valueBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * 
+       ** list of values 
+       *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public Builder addValue( + int index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder builderForValue) { + if (valueBuilder_ == null) { + ensureValueIsMutable(); + value_.add(index, builderForValue.build()); + onChanged(); + } else { + valueBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** list of values 
+       *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public Builder addAllValue( + java.lang.Iterable values) { + if (valueBuilder_ == null) { + ensureValueIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, value_); + onChanged(); + } else { + valueBuilder_.addAllMessages(values); + } + return this; + } + /** + * 
+       ** list of values 
+       *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public Builder clearValue() { + if (valueBuilder_ == null) { + value_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + } else { + valueBuilder_.clear(); + } + return this; + } + /** + * 
+       ** list of values 
+       *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public Builder removeValue(int index) { + if (valueBuilder_ == null) { + ensureValueIsMutable(); + value_.remove(index); + onChanged(); + } else { + valueBuilder_.remove(index); + } + return this; + } + /** + * 
+       ** list of values 
+       *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder getValueBuilder( + int index) { + return getValueFieldBuilder().getBuilder(index); + } + /** + * 
+       ** list of values 
+       *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder getValueOrBuilder( + int index) { + if (valueBuilder_ == null) { + return value_.get(index); } else { + return valueBuilder_.getMessageOrBuilder(index); + } + } + /** + * 
+       ** list of values 
+       *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public java.util.List + getValueOrBuilderList() { + if (valueBuilder_ != null) { + return valueBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(value_); + } + } + /** + * 
+       ** list of values 
+       *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder addValueBuilder() { + return getValueFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance()); + } + /** + * 
+       ** list of values 
+       *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder addValueBuilder( + int index) { + return getValueFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.getDefaultInstance()); + } + /** + * 
+       ** list of values 
+       *
+ * + * repeated .Mysqlx.Expr.Expr value = 1; + */ + public java.util.List + getValueBuilderList() { + return getValueFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder> + getValueFieldBuilder() { + if (valueBuilder_ == null) { + valueBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxExpr.Expr, com.mysql.cj.x.protobuf.MysqlxExpr.Expr.Builder, com.mysql.cj.x.protobuf.MysqlxExpr.ExprOrBuilder>( + value_, + ((bitField0_ & 0x00000001) != 0), + getParentForChildren(), + isClean()); + value_ = null; + } + return valueBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Expr.Array) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Expr.Array) + private static final com.mysql.cj.x.protobuf.MysqlxExpr.Array DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxExpr.Array(); + } + + public static com.mysql.cj.x.protobuf.MysqlxExpr.Array getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Array parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Array(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxExpr.Array getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Expr_Expr_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Expr_Expr_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Expr_Identifier_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Expr_Identifier_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Expr_DocumentPathItem_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Expr_DocumentPathItem_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Expr_ColumnIdentifier_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Expr_ColumnIdentifier_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Expr_FunctionCall_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Expr_FunctionCall_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Expr_Operator_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Expr_Operator_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Expr_Object_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Expr_Object_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Expr_Object_ObjectField_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Expr_Object_ObjectField_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Expr_Array_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Expr_Array_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\021mysqlx_expr.proto\022\013Mysqlx.Expr\032\026mysqlx" + + "_datatypes.proto\"\304\003\n\004Expr\022$\n\004type\030\001 \002(\0162" + + "\026.Mysqlx.Expr.Expr.Type\0221\n\nidentifier\030\002 " + + "\001(\0132\035.Mysqlx.Expr.ColumnIdentifier\022\020\n\010va" + + "riable\030\003 \001(\t\022)\n\007literal\030\004 \001(\0132\030.Mysqlx.D" + + "atatypes.Scalar\0220\n\rfunction_call\030\005 \001(\0132\031" + + ".Mysqlx.Expr.FunctionCall\022\'\n\010operator\030\006 " + + "\001(\0132\025.Mysqlx.Expr.Operator\022\020\n\010position\030\007" + + " \001(\r\022#\n\006object\030\010 \001(\0132\023.Mysqlx.Expr.Objec" + + "t\022!\n\005array\030\t \001(\0132\022.Mysqlx.Expr.Array\"q\n\004" + + "Type\022\t\n\005IDENT\020\001\022\013\n\007LITERAL\020\002\022\014\n\010VARIABLE" + + "\020\003\022\r\n\tFUNC_CALL\020\004\022\014\n\010OPERATOR\020\005\022\017\n\013PLACE" + + "HOLDER\020\006\022\n\n\006OBJECT\020\007\022\t\n\005ARRAY\020\010\"/\n\nIdent" + + "ifier\022\014\n\004name\030\001 \002(\t\022\023\n\013schema_name\030\002 \001(\t" + + "\"\313\001\n\020DocumentPathItem\0220\n\004type\030\001 \002(\0162\".My" + + "sqlx.Expr.DocumentPathItem.Type\022\r\n\005value" + + "\030\002 \001(\t\022\r\n\005index\030\003 \001(\r\"g\n\004Type\022\n\n\006MEMBER\020" + + "\001\022\023\n\017MEMBER_ASTERISK\020\002\022\017\n\013ARRAY_INDEX\020\003\022" + + "\030\n\024ARRAY_INDEX_ASTERISK\020\004\022\023\n\017DOUBLE_ASTE" + + "RISK\020\005\"\177\n\020ColumnIdentifier\0224\n\rdocument_p" + + "ath\030\001 \003(\0132\035.Mysqlx.Expr.DocumentPathItem" + + "\022\014\n\004name\030\002 \001(\t\022\022\n\ntable_name\030\003 \001(\t\022\023\n\013sc" + + "hema_name\030\004 \001(\t\"W\n\014FunctionCall\022%\n\004name\030" + + "\001 \002(\0132\027.Mysqlx.Expr.Identifier\022 \n\005param\030" + + "\002 \003(\0132\021.Mysqlx.Expr.Expr\":\n\010Operator\022\014\n\004" + + "name\030\001 \002(\t\022 \n\005param\030\002 \003(\0132\021.Mysqlx.Expr." + + "Expr\"t\n\006Object\022,\n\003fld\030\001 \003(\0132\037.Mysqlx.Exp" + + "r.Object.ObjectField\032<\n\013ObjectField\022\013\n\003k" + + "ey\030\001 \002(\t\022 \n\005value\030\002 \002(\0132\021.Mysqlx.Expr.Ex" + + "pr\")\n\005Array\022 \n\005value\030\001 \003(\0132\021.Mysqlx.Expr" + + ".ExprB\031\n\027com.mysql.cj.x.protobuf" + }; + descriptor = com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + com.mysql.cj.x.protobuf.MysqlxDatatypes.getDescriptor(), + }); + internal_static_Mysqlx_Expr_Expr_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_Mysqlx_Expr_Expr_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Expr_Expr_descriptor, + new java.lang.String[] { "Type", "Identifier", "Variable", "Literal", "FunctionCall", "Operator", "Position", "Object", "Array", }); + internal_static_Mysqlx_Expr_Identifier_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_Mysqlx_Expr_Identifier_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Expr_Identifier_descriptor, + new java.lang.String[] { "Name", "SchemaName", }); + internal_static_Mysqlx_Expr_DocumentPathItem_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_Mysqlx_Expr_DocumentPathItem_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Expr_DocumentPathItem_descriptor, + new java.lang.String[] { "Type", "Value", "Index", }); + internal_static_Mysqlx_Expr_ColumnIdentifier_descriptor = + getDescriptor().getMessageTypes().get(3); + internal_static_Mysqlx_Expr_ColumnIdentifier_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Expr_ColumnIdentifier_descriptor, + new java.lang.String[] { "DocumentPath", "Name", "TableName", "SchemaName", }); + internal_static_Mysqlx_Expr_FunctionCall_descriptor = + getDescriptor().getMessageTypes().get(4); + internal_static_Mysqlx_Expr_FunctionCall_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Expr_FunctionCall_descriptor, + new java.lang.String[] { "Name", "Param", }); + internal_static_Mysqlx_Expr_Operator_descriptor = + getDescriptor().getMessageTypes().get(5); + internal_static_Mysqlx_Expr_Operator_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Expr_Operator_descriptor, + new java.lang.String[] { "Name", "Param", }); + internal_static_Mysqlx_Expr_Object_descriptor = + getDescriptor().getMessageTypes().get(6); + internal_static_Mysqlx_Expr_Object_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Expr_Object_descriptor, + new java.lang.String[] { "Fld", }); + internal_static_Mysqlx_Expr_Object_ObjectField_descriptor = + internal_static_Mysqlx_Expr_Object_descriptor.getNestedTypes().get(0); + internal_static_Mysqlx_Expr_Object_ObjectField_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Expr_Object_ObjectField_descriptor, + new java.lang.String[] { "Key", "Value", }); + internal_static_Mysqlx_Expr_Array_descriptor = + getDescriptor().getMessageTypes().get(7); + internal_static_Mysqlx_Expr_Array_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Expr_Array_descriptor, + new java.lang.String[] { "Value", }); + com.mysql.cj.x.protobuf.MysqlxDatatypes.getDescriptor(); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxNotice.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxNotice.java new file mode 100644 index 0000000..36da269 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxNotice.java @@ -0,0 +1,5885 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.x.protobuf; + +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: mysqlx_notice.proto + +@SuppressWarnings({ "deprecation" }) +public final class MysqlxNotice { + private MysqlxNotice() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + public interface FrameOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Notice.Frame) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** the type of the payload 
+     *
+ * + * required uint32 type = 1; + * @return Whether the type field is set. + */ + boolean hasType(); + /** + * 
+     ** the type of the payload 
+     *
+ * + * required uint32 type = 1; + * @return The type. + */ + int getType(); + + /** + * 
+     ** global or local notification 
+     *
+ * + * optional .Mysqlx.Notice.Frame.Scope scope = 2 [default = GLOBAL]; + * @return Whether the scope field is set. + */ + boolean hasScope(); + /** + * 
+     ** global or local notification 
+     *
+ * + * optional .Mysqlx.Notice.Frame.Scope scope = 2 [default = GLOBAL]; + * @return The scope. + */ + com.mysql.cj.x.protobuf.MysqlxNotice.Frame.Scope getScope(); + + /** + * 
+     ** the payload of the notification 
+     *
+ * + * optional bytes payload = 3; + * @return Whether the payload field is set. + */ + boolean hasPayload(); + /** + * 
+     ** the payload of the notification 
+     *
+ * + * optional bytes payload = 3; + * @return The payload. + */ + com.google.protobuf.ByteString getPayload(); + } + /** + * 
+   **
+   *Common frame for all notices
+   *| ``.type``                                         | Value |
+   *|---------------------------------------------------|------ |
+   *| @ref Mysqlx::Notice::Warning                      | 1     |
+   *| @ref Mysqlx::Notice::SessionVariableChanged       | 2     |
+   *| @ref Mysqlx::Notice::SessionStateChanged          | 3     |
+   *| @ref Mysqlx::Notice::GroupReplicationStateChanged | 4     |
+   *| @ref Mysqlx::Notice::ServerHello                  | 5     |
+   *
+ * + * Protobuf type {@code Mysqlx.Notice.Frame} + */ + public static final class Frame extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Notice.Frame) + FrameOrBuilder { + private static final long serialVersionUID = 0L; + // Use Frame.newBuilder() to construct. + private Frame(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Frame() { + scope_ = 1; + payload_ = com.google.protobuf.ByteString.EMPTY; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Frame(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Frame( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + bitField0_ |= 0x00000001; + type_ = input.readUInt32(); + break; + } + case 16: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxNotice.Frame.Scope value = com.mysql.cj.x.protobuf.MysqlxNotice.Frame.Scope.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(2, rawValue); + } else { + bitField0_ |= 0x00000002; + scope_ = rawValue; + } + break; + } + case 26: { + bitField0_ |= 0x00000004; + payload_ = input.readBytes(); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_Frame_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_Frame_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxNotice.Frame.class, com.mysql.cj.x.protobuf.MysqlxNotice.Frame.Builder.class); + } + + /** + * 
+     ** scope of notice 
+     *
+ * + * Protobuf enum {@code Mysqlx.Notice.Frame.Scope} + */ + public enum Scope + implements com.google.protobuf.ProtocolMessageEnum { + /** + * GLOBAL = 1; + */ + GLOBAL(1), + /** + * LOCAL = 2; + */ + LOCAL(2), + ; + + /** + * GLOBAL = 1; + */ + public static final int GLOBAL_VALUE = 1; + /** + * LOCAL = 2; + */ + public static final int LOCAL_VALUE = 2; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static Scope valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static Scope forNumber(int value) { + switch (value) { + case 1: return GLOBAL; + case 2: return LOCAL; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + Scope> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Scope findValueByNumber(int number) { + return Scope.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxNotice.Frame.getDescriptor().getEnumTypes().get(0); + } + + private static final Scope[] VALUES = values(); + + public static Scope valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private Scope(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Notice.Frame.Scope) + } + + /** + * 
+     ** type of notice payload
+     *
+ * + * Protobuf enum {@code Mysqlx.Notice.Frame.Type} + */ + public enum Type + implements com.google.protobuf.ProtocolMessageEnum { + /** + * WARNING = 1; + */ + WARNING(1), + /** + * SESSION_VARIABLE_CHANGED = 2; + */ + SESSION_VARIABLE_CHANGED(2), + /** + * SESSION_STATE_CHANGED = 3; + */ + SESSION_STATE_CHANGED(3), + /** + * GROUP_REPLICATION_STATE_CHANGED = 4; + */ + GROUP_REPLICATION_STATE_CHANGED(4), + /** + * SERVER_HELLO = 5; + */ + SERVER_HELLO(5), + ; + + /** + * WARNING = 1; + */ + public static final int WARNING_VALUE = 1; + /** + * SESSION_VARIABLE_CHANGED = 2; + */ + public static final int SESSION_VARIABLE_CHANGED_VALUE = 2; + /** + * SESSION_STATE_CHANGED = 3; + */ + public static final int SESSION_STATE_CHANGED_VALUE = 3; + /** + * GROUP_REPLICATION_STATE_CHANGED = 4; + */ + public static final int GROUP_REPLICATION_STATE_CHANGED_VALUE = 4; + /** + * SERVER_HELLO = 5; + */ + public static final int SERVER_HELLO_VALUE = 5; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static Type valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static Type forNumber(int value) { + switch (value) { + case 1: return WARNING; + case 2: return SESSION_VARIABLE_CHANGED; + case 3: return SESSION_STATE_CHANGED; + case 4: return GROUP_REPLICATION_STATE_CHANGED; + case 5: return SERVER_HELLO; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + Type> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Type findValueByNumber(int number) { + return Type.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxNotice.Frame.getDescriptor().getEnumTypes().get(1); + } + + private static final Type[] VALUES = values(); + + public static Type valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private Type(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Notice.Frame.Type) + } + + private int bitField0_; + public static final int TYPE_FIELD_NUMBER = 1; + private int type_; + /** + * 
+     ** the type of the payload 
+     *
+ * + * required uint32 type = 1; + * @return Whether the type field is set. + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** the type of the payload 
+     *
+ * + * required uint32 type = 1; + * @return The type. + */ + public int getType() { + return type_; + } + + public static final int SCOPE_FIELD_NUMBER = 2; + private int scope_; + /** + * 
+     ** global or local notification 
+     *
+ * + * optional .Mysqlx.Notice.Frame.Scope scope = 2 [default = GLOBAL]; + * @return Whether the scope field is set. + */ + public boolean hasScope() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** global or local notification 
+     *
+ * + * optional .Mysqlx.Notice.Frame.Scope scope = 2 [default = GLOBAL]; + * @return The scope. + */ + public com.mysql.cj.x.protobuf.MysqlxNotice.Frame.Scope getScope() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxNotice.Frame.Scope result = com.mysql.cj.x.protobuf.MysqlxNotice.Frame.Scope.valueOf(scope_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxNotice.Frame.Scope.GLOBAL : result; + } + + public static final int PAYLOAD_FIELD_NUMBER = 3; + private com.google.protobuf.ByteString payload_; + /** + * 
+     ** the payload of the notification 
+     *
+ * + * optional bytes payload = 3; + * @return Whether the payload field is set. + */ + public boolean hasPayload() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+     ** the payload of the notification 
+     *
+ * + * optional bytes payload = 3; + * @return The payload. + */ + public com.google.protobuf.ByteString getPayload() { + return payload_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasType()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeUInt32(1, type_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeEnum(2, scope_); + } + if (((bitField0_ & 0x00000004) != 0)) { + output.writeBytes(3, payload_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(1, type_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(2, scope_); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(3, payload_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxNotice.Frame)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxNotice.Frame other = (com.mysql.cj.x.protobuf.MysqlxNotice.Frame) obj; + + if (hasType() != other.hasType()) return false; + if (hasType()) { + if (getType() + != other.getType()) return false; + } + if (hasScope() != other.hasScope()) return false; + if (hasScope()) { + if (scope_ != other.scope_) return false; + } + if (hasPayload() != other.hasPayload()) return false; + if (hasPayload()) { + if (!getPayload() + .equals(other.getPayload())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasType()) { + hash = (37 * hash) + TYPE_FIELD_NUMBER; + hash = (53 * hash) + getType(); + } + if (hasScope()) { + hash = (37 * hash) + SCOPE_FIELD_NUMBER; + hash = (53 * hash) + scope_; + } + if (hasPayload()) { + hash = (37 * hash) + PAYLOAD_FIELD_NUMBER; + hash = (53 * hash) + getPayload().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxNotice.Frame parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Frame parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Frame parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Frame parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Frame parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Frame parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Frame parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Frame parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Frame parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Frame parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Frame parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Frame parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxNotice.Frame prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Common frame for all notices
+     *| ``.type``                                         | Value |
+     *|---------------------------------------------------|------ |
+     *| @ref Mysqlx::Notice::Warning                      | 1     |
+     *| @ref Mysqlx::Notice::SessionVariableChanged       | 2     |
+     *| @ref Mysqlx::Notice::SessionStateChanged          | 3     |
+     *| @ref Mysqlx::Notice::GroupReplicationStateChanged | 4     |
+     *| @ref Mysqlx::Notice::ServerHello                  | 5     |
+     *
+ * + * Protobuf type {@code Mysqlx.Notice.Frame} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Notice.Frame) + com.mysql.cj.x.protobuf.MysqlxNotice.FrameOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_Frame_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_Frame_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxNotice.Frame.class, com.mysql.cj.x.protobuf.MysqlxNotice.Frame.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxNotice.Frame.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + type_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + scope_ = 1; + bitField0_ = (bitField0_ & ~0x00000002); + payload_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_Frame_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.Frame getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxNotice.Frame.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.Frame build() { + com.mysql.cj.x.protobuf.MysqlxNotice.Frame result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.Frame buildPartial() { + com.mysql.cj.x.protobuf.MysqlxNotice.Frame result = new com.mysql.cj.x.protobuf.MysqlxNotice.Frame(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.type_ = type_; + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + to_bitField0_ |= 0x00000002; + } + result.scope_ = scope_; + if (((from_bitField0_ & 0x00000004) != 0)) { + to_bitField0_ |= 0x00000004; + } + result.payload_ = payload_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxNotice.Frame) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxNotice.Frame)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxNotice.Frame other) { + if (other == com.mysql.cj.x.protobuf.MysqlxNotice.Frame.getDefaultInstance()) return this; + if (other.hasType()) { + setType(other.getType()); + } + if (other.hasScope()) { + setScope(other.getScope()); + } + if (other.hasPayload()) { + setPayload(other.getPayload()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasType()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxNotice.Frame parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxNotice.Frame) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int type_ ; + /** + * 
+       ** the type of the payload 
+       *
+ * + * required uint32 type = 1; + * @return Whether the type field is set. + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** the type of the payload 
+       *
+ * + * required uint32 type = 1; + * @return The type. + */ + public int getType() { + return type_; + } + /** + * 
+       ** the type of the payload 
+       *
+ * + * required uint32 type = 1; + * @param value The type to set. + * @return This builder for chaining. + */ + public Builder setType(int value) { + bitField0_ |= 0x00000001; + type_ = value; + onChanged(); + return this; + } + /** + * 
+       ** the type of the payload 
+       *
+ * + * required uint32 type = 1; + * @return This builder for chaining. + */ + public Builder clearType() { + bitField0_ = (bitField0_ & ~0x00000001); + type_ = 0; + onChanged(); + return this; + } + + private int scope_ = 1; + /** + * 
+       ** global or local notification 
+       *
+ * + * optional .Mysqlx.Notice.Frame.Scope scope = 2 [default = GLOBAL]; + * @return Whether the scope field is set. + */ + public boolean hasScope() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** global or local notification 
+       *
+ * + * optional .Mysqlx.Notice.Frame.Scope scope = 2 [default = GLOBAL]; + * @return The scope. + */ + public com.mysql.cj.x.protobuf.MysqlxNotice.Frame.Scope getScope() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxNotice.Frame.Scope result = com.mysql.cj.x.protobuf.MysqlxNotice.Frame.Scope.valueOf(scope_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxNotice.Frame.Scope.GLOBAL : result; + } + /** + * 
+       ** global or local notification 
+       *
+ * + * optional .Mysqlx.Notice.Frame.Scope scope = 2 [default = GLOBAL]; + * @param value The scope to set. + * @return This builder for chaining. + */ + public Builder setScope(com.mysql.cj.x.protobuf.MysqlxNotice.Frame.Scope value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + scope_ = value.getNumber(); + onChanged(); + return this; + } + /** + * 
+       ** global or local notification 
+       *
+ * + * optional .Mysqlx.Notice.Frame.Scope scope = 2 [default = GLOBAL]; + * @return This builder for chaining. + */ + public Builder clearScope() { + bitField0_ = (bitField0_ & ~0x00000002); + scope_ = 1; + onChanged(); + return this; + } + + private com.google.protobuf.ByteString payload_ = com.google.protobuf.ByteString.EMPTY; + /** + * 
+       ** the payload of the notification 
+       *
+ * + * optional bytes payload = 3; + * @return Whether the payload field is set. + */ + public boolean hasPayload() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+       ** the payload of the notification 
+       *
+ * + * optional bytes payload = 3; + * @return The payload. + */ + public com.google.protobuf.ByteString getPayload() { + return payload_; + } + /** + * 
+       ** the payload of the notification 
+       *
+ * + * optional bytes payload = 3; + * @param value The payload to set. + * @return This builder for chaining. + */ + public Builder setPayload(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + payload_ = value; + onChanged(); + return this; + } + /** + * 
+       ** the payload of the notification 
+       *
+ * + * optional bytes payload = 3; + * @return This builder for chaining. + */ + public Builder clearPayload() { + bitField0_ = (bitField0_ & ~0x00000004); + payload_ = getDefaultInstance().getPayload(); + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Notice.Frame) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Notice.Frame) + private static final com.mysql.cj.x.protobuf.MysqlxNotice.Frame DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxNotice.Frame(); + } + + public static com.mysql.cj.x.protobuf.MysqlxNotice.Frame getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Frame parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Frame(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.Frame getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface WarningOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Notice.Warning) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** Note or Warning 
+     *
+ * + * optional .Mysqlx.Notice.Warning.Level level = 1 [default = WARNING]; + * @return Whether the level field is set. + */ + boolean hasLevel(); + /** + * 
+     ** Note or Warning 
+     *
+ * + * optional .Mysqlx.Notice.Warning.Level level = 1 [default = WARNING]; + * @return The level. + */ + com.mysql.cj.x.protobuf.MysqlxNotice.Warning.Level getLevel(); + + /** + * 
+     ** warning code 
+     *
+ * + * required uint32 code = 2; + * @return Whether the code field is set. + */ + boolean hasCode(); + /** + * 
+     ** warning code 
+     *
+ * + * required uint32 code = 2; + * @return The code. + */ + int getCode(); + + /** + * 
+     ** warning message 
+     *
+ * + * required string msg = 3; + * @return Whether the msg field is set. + */ + boolean hasMsg(); + /** + * 
+     ** warning message 
+     *
+ * + * required string msg = 3; + * @return The msg. + */ + java.lang.String getMsg(); + /** + * 
+     ** warning message 
+     *
+ * + * required string msg = 3; + * @return The bytes for msg. + */ + com.google.protobuf.ByteString + getMsgBytes(); + } + /** + * 
+   **
+   *Server-side warnings and notes
+   *@par ``.scope`` == ``local``
+   *``.level``, ``.code`` and ``.msg`` map the content of:
+   *@code{sql}
+   *SHOW WARNINGS
+   *@endcode
+   *@par ``.scope`` == ``global``
+   *(undefined) Will be used for global, unstructured messages like:
+   *-  server is shutting down
+   *-  a node disconnected from group
+   *-  schema or table dropped
+   *| @ref Mysqlx::Notice::Frame Field  | Value                   |
+   *|-----------------------------------|-------------------------|
+   *| ``.type``                         | 1                       |
+   *| ``.scope``                        | ``local`` or ``global`` |
+   *
+ * + * Protobuf type {@code Mysqlx.Notice.Warning} + */ + public static final class Warning extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Notice.Warning) + WarningOrBuilder { + private static final long serialVersionUID = 0L; + // Use Warning.newBuilder() to construct. + private Warning(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Warning() { + level_ = 2; + msg_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Warning(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Warning( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxNotice.Warning.Level value = com.mysql.cj.x.protobuf.MysqlxNotice.Warning.Level.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(1, rawValue); + } else { + bitField0_ |= 0x00000001; + level_ = rawValue; + } + break; + } + case 16: { + bitField0_ |= 0x00000002; + code_ = input.readUInt32(); + break; + } + case 26: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000004; + msg_ = bs; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_Warning_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_Warning_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxNotice.Warning.class, com.mysql.cj.x.protobuf.MysqlxNotice.Warning.Builder.class); + } + + /** + * Protobuf enum {@code Mysqlx.Notice.Warning.Level} + */ + public enum Level + implements com.google.protobuf.ProtocolMessageEnum { + /** + * NOTE = 1; + */ + NOTE(1), + /** + * WARNING = 2; + */ + WARNING(2), + /** + * ERROR = 3; + */ + ERROR(3), + ; + + /** + * NOTE = 1; + */ + public static final int NOTE_VALUE = 1; + /** + * WARNING = 2; + */ + public static final int WARNING_VALUE = 2; + /** + * ERROR = 3; + */ + public static final int ERROR_VALUE = 3; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static Level valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static Level forNumber(int value) { + switch (value) { + case 1: return NOTE; + case 2: return WARNING; + case 3: return ERROR; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + Level> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Level findValueByNumber(int number) { + return Level.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxNotice.Warning.getDescriptor().getEnumTypes().get(0); + } + + private static final Level[] VALUES = values(); + + public static Level valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private Level(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Notice.Warning.Level) + } + + private int bitField0_; + public static final int LEVEL_FIELD_NUMBER = 1; + private int level_; + /** + * 
+     ** Note or Warning 
+     *
+ * + * optional .Mysqlx.Notice.Warning.Level level = 1 [default = WARNING]; + * @return Whether the level field is set. + */ + public boolean hasLevel() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** Note or Warning 
+     *
+ * + * optional .Mysqlx.Notice.Warning.Level level = 1 [default = WARNING]; + * @return The level. + */ + public com.mysql.cj.x.protobuf.MysqlxNotice.Warning.Level getLevel() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxNotice.Warning.Level result = com.mysql.cj.x.protobuf.MysqlxNotice.Warning.Level.valueOf(level_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxNotice.Warning.Level.WARNING : result; + } + + public static final int CODE_FIELD_NUMBER = 2; + private int code_; + /** + * 
+     ** warning code 
+     *
+ * + * required uint32 code = 2; + * @return Whether the code field is set. + */ + public boolean hasCode() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** warning code 
+     *
+ * + * required uint32 code = 2; + * @return The code. + */ + public int getCode() { + return code_; + } + + public static final int MSG_FIELD_NUMBER = 3; + private volatile java.lang.Object msg_; + /** + * 
+     ** warning message 
+     *
+ * + * required string msg = 3; + * @return Whether the msg field is set. + */ + public boolean hasMsg() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+     ** warning message 
+     *
+ * + * required string msg = 3; + * @return The msg. + */ + public java.lang.String getMsg() { + java.lang.Object ref = msg_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + msg_ = s; + } + return s; + } + } + /** + * 
+     ** warning message 
+     *
+ * + * required string msg = 3; + * @return The bytes for msg. + */ + public com.google.protobuf.ByteString + getMsgBytes() { + java.lang.Object ref = msg_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + msg_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasCode()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasMsg()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeEnum(1, level_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeUInt32(2, code_); + } + if (((bitField0_ & 0x00000004) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 3, msg_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(1, level_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(2, code_); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, msg_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxNotice.Warning)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxNotice.Warning other = (com.mysql.cj.x.protobuf.MysqlxNotice.Warning) obj; + + if (hasLevel() != other.hasLevel()) return false; + if (hasLevel()) { + if (level_ != other.level_) return false; + } + if (hasCode() != other.hasCode()) return false; + if (hasCode()) { + if (getCode() + != other.getCode()) return false; + } + if (hasMsg() != other.hasMsg()) return false; + if (hasMsg()) { + if (!getMsg() + .equals(other.getMsg())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasLevel()) { + hash = (37 * hash) + LEVEL_FIELD_NUMBER; + hash = (53 * hash) + level_; + } + if (hasCode()) { + hash = (37 * hash) + CODE_FIELD_NUMBER; + hash = (53 * hash) + getCode(); + } + if (hasMsg()) { + hash = (37 * hash) + MSG_FIELD_NUMBER; + hash = (53 * hash) + getMsg().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxNotice.Warning parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Warning parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Warning parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Warning parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Warning parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Warning parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Warning parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Warning parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Warning parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Warning parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Warning parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.Warning parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxNotice.Warning prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Server-side warnings and notes
+     *@par ``.scope`` == ``local``
+     *``.level``, ``.code`` and ``.msg`` map the content of:
+     *@code{sql}
+     *SHOW WARNINGS
+     *@endcode
+     *@par ``.scope`` == ``global``
+     *(undefined) Will be used for global, unstructured messages like:
+     *-  server is shutting down
+     *-  a node disconnected from group
+     *-  schema or table dropped
+     *| @ref Mysqlx::Notice::Frame Field  | Value                   |
+     *|-----------------------------------|-------------------------|
+     *| ``.type``                         | 1                       |
+     *| ``.scope``                        | ``local`` or ``global`` |
+     *
+ * + * Protobuf type {@code Mysqlx.Notice.Warning} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Notice.Warning) + com.mysql.cj.x.protobuf.MysqlxNotice.WarningOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_Warning_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_Warning_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxNotice.Warning.class, com.mysql.cj.x.protobuf.MysqlxNotice.Warning.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxNotice.Warning.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + level_ = 2; + bitField0_ = (bitField0_ & ~0x00000001); + code_ = 0; + bitField0_ = (bitField0_ & ~0x00000002); + msg_ = ""; + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_Warning_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.Warning getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxNotice.Warning.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.Warning build() { + com.mysql.cj.x.protobuf.MysqlxNotice.Warning result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.Warning buildPartial() { + com.mysql.cj.x.protobuf.MysqlxNotice.Warning result = new com.mysql.cj.x.protobuf.MysqlxNotice.Warning(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.level_ = level_; + if (((from_bitField0_ & 0x00000002) != 0)) { + result.code_ = code_; + to_bitField0_ |= 0x00000002; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + to_bitField0_ |= 0x00000004; + } + result.msg_ = msg_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxNotice.Warning) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxNotice.Warning)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxNotice.Warning other) { + if (other == com.mysql.cj.x.protobuf.MysqlxNotice.Warning.getDefaultInstance()) return this; + if (other.hasLevel()) { + setLevel(other.getLevel()); + } + if (other.hasCode()) { + setCode(other.getCode()); + } + if (other.hasMsg()) { + bitField0_ |= 0x00000004; + msg_ = other.msg_; + onChanged(); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasCode()) { + return false; + } + if (!hasMsg()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxNotice.Warning parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxNotice.Warning) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int level_ = 2; + /** + * 
+       ** Note or Warning 
+       *
+ * + * optional .Mysqlx.Notice.Warning.Level level = 1 [default = WARNING]; + * @return Whether the level field is set. + */ + public boolean hasLevel() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** Note or Warning 
+       *
+ * + * optional .Mysqlx.Notice.Warning.Level level = 1 [default = WARNING]; + * @return The level. + */ + public com.mysql.cj.x.protobuf.MysqlxNotice.Warning.Level getLevel() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxNotice.Warning.Level result = com.mysql.cj.x.protobuf.MysqlxNotice.Warning.Level.valueOf(level_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxNotice.Warning.Level.WARNING : result; + } + /** + * 
+       ** Note or Warning 
+       *
+ * + * optional .Mysqlx.Notice.Warning.Level level = 1 [default = WARNING]; + * @param value The level to set. + * @return This builder for chaining. + */ + public Builder setLevel(com.mysql.cj.x.protobuf.MysqlxNotice.Warning.Level value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + level_ = value.getNumber(); + onChanged(); + return this; + } + /** + * 
+       ** Note or Warning 
+       *
+ * + * optional .Mysqlx.Notice.Warning.Level level = 1 [default = WARNING]; + * @return This builder for chaining. + */ + public Builder clearLevel() { + bitField0_ = (bitField0_ & ~0x00000001); + level_ = 2; + onChanged(); + return this; + } + + private int code_ ; + /** + * 
+       ** warning code 
+       *
+ * + * required uint32 code = 2; + * @return Whether the code field is set. + */ + public boolean hasCode() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** warning code 
+       *
+ * + * required uint32 code = 2; + * @return The code. + */ + public int getCode() { + return code_; + } + /** + * 
+       ** warning code 
+       *
+ * + * required uint32 code = 2; + * @param value The code to set. + * @return This builder for chaining. + */ + public Builder setCode(int value) { + bitField0_ |= 0x00000002; + code_ = value; + onChanged(); + return this; + } + /** + * 
+       ** warning code 
+       *
+ * + * required uint32 code = 2; + * @return This builder for chaining. + */ + public Builder clearCode() { + bitField0_ = (bitField0_ & ~0x00000002); + code_ = 0; + onChanged(); + return this; + } + + private java.lang.Object msg_ = ""; + /** + * 
+       ** warning message 
+       *
+ * + * required string msg = 3; + * @return Whether the msg field is set. + */ + public boolean hasMsg() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+       ** warning message 
+       *
+ * + * required string msg = 3; + * @return The msg. + */ + public java.lang.String getMsg() { + java.lang.Object ref = msg_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + msg_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * 
+       ** warning message 
+       *
+ * + * required string msg = 3; + * @return The bytes for msg. + */ + public com.google.protobuf.ByteString + getMsgBytes() { + java.lang.Object ref = msg_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + msg_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * 
+       ** warning message 
+       *
+ * + * required string msg = 3; + * @param value The msg to set. + * @return This builder for chaining. + */ + public Builder setMsg( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + msg_ = value; + onChanged(); + return this; + } + /** + * 
+       ** warning message 
+       *
+ * + * required string msg = 3; + * @return This builder for chaining. + */ + public Builder clearMsg() { + bitField0_ = (bitField0_ & ~0x00000004); + msg_ = getDefaultInstance().getMsg(); + onChanged(); + return this; + } + /** + * 
+       ** warning message 
+       *
+ * + * required string msg = 3; + * @param value The bytes for msg to set. + * @return This builder for chaining. + */ + public Builder setMsgBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + msg_ = value; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Notice.Warning) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Notice.Warning) + private static final com.mysql.cj.x.protobuf.MysqlxNotice.Warning DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxNotice.Warning(); + } + + public static com.mysql.cj.x.protobuf.MysqlxNotice.Warning getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Warning parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Warning(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.Warning getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface SessionVariableChangedOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Notice.SessionVariableChanged) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** name of the variable 
+     *
+ * + * required string param = 1; + * @return Whether the param field is set. + */ + boolean hasParam(); + /** + * 
+     ** name of the variable 
+     *
+ * + * required string param = 1; + * @return The param. + */ + java.lang.String getParam(); + /** + * 
+     ** name of the variable 
+     *
+ * + * required string param = 1; + * @return The bytes for param. + */ + com.google.protobuf.ByteString + getParamBytes(); + + /** + * 
+     ** the changed value of param 
+     *
+ * + * optional .Mysqlx.Datatypes.Scalar value = 2; + * @return Whether the value field is set. + */ + boolean hasValue(); + /** + * 
+     ** the changed value of param 
+     *
+ * + * optional .Mysqlx.Datatypes.Scalar value = 2; + * @return The value. + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getValue(); + /** + * 
+     ** the changed value of param 
+     *
+ * + * optional .Mysqlx.Datatypes.Scalar value = 2; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getValueOrBuilder(); + } + /** + * 
+   **
+   *Notify clients about changes to the current session variables.
+   *Every change to a variable that is accessible through:
+   *@code{sql}
+   *SHOW SESSION VARIABLES
+   *@endcode
+   *| @ref Mysqlx::Notice::Frame  Field | Value    |
+   *|-----------------------------------|----------|
+   *| ``.type``                         | 2        |
+   *| ``.scope``                        | ``local``|
+   *
+ * + * Protobuf type {@code Mysqlx.Notice.SessionVariableChanged} + */ + public static final class SessionVariableChanged extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Notice.SessionVariableChanged) + SessionVariableChangedOrBuilder { + private static final long serialVersionUID = 0L; + // Use SessionVariableChanged.newBuilder() to construct. + private SessionVariableChanged(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private SessionVariableChanged() { + param_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new SessionVariableChanged(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private SessionVariableChanged( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000001; + param_ = bs; + break; + } + case 18: { + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) != 0)) { + subBuilder = value_.toBuilder(); + } + value_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(value_); + value_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_SessionVariableChanged_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_SessionVariableChanged_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged.class, com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged.Builder.class); + } + + private int bitField0_; + public static final int PARAM_FIELD_NUMBER = 1; + private volatile java.lang.Object param_; + /** + * 
+     ** name of the variable 
+     *
+ * + * required string param = 1; + * @return Whether the param field is set. + */ + public boolean hasParam() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** name of the variable 
+     *
+ * + * required string param = 1; + * @return The param. + */ + public java.lang.String getParam() { + java.lang.Object ref = param_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + param_ = s; + } + return s; + } + } + /** + * 
+     ** name of the variable 
+     *
+ * + * required string param = 1; + * @return The bytes for param. + */ + public com.google.protobuf.ByteString + getParamBytes() { + java.lang.Object ref = param_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + param_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int VALUE_FIELD_NUMBER = 2; + private com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value_; + /** + * 
+     ** the changed value of param 
+     *
+ * + * optional .Mysqlx.Datatypes.Scalar value = 2; + * @return Whether the value field is set. + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** the changed value of param 
+     *
+ * + * optional .Mysqlx.Datatypes.Scalar value = 2; + * @return The value. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getValue() { + return value_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance() : value_; + } + /** + * 
+     ** the changed value of param 
+     *
+ * + * optional .Mysqlx.Datatypes.Scalar value = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getValueOrBuilder() { + return value_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance() : value_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasParam()) { + memoizedIsInitialized = 0; + return false; + } + if (hasValue()) { + if (!getValue().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, param_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeMessage(2, getValue()); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, param_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, getValue()); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged other = (com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged) obj; + + if (hasParam() != other.hasParam()) return false; + if (hasParam()) { + if (!getParam() + .equals(other.getParam())) return false; + } + if (hasValue() != other.hasValue()) return false; + if (hasValue()) { + if (!getValue() + .equals(other.getValue())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasParam()) { + hash = (37 * hash) + PARAM_FIELD_NUMBER; + hash = (53 * hash) + getParam().hashCode(); + } + if (hasValue()) { + hash = (37 * hash) + VALUE_FIELD_NUMBER; + hash = (53 * hash) + getValue().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Notify clients about changes to the current session variables.
+     *Every change to a variable that is accessible through:
+     *@code{sql}
+     *SHOW SESSION VARIABLES
+     *@endcode
+     *| @ref Mysqlx::Notice::Frame  Field | Value    |
+     *|-----------------------------------|----------|
+     *| ``.type``                         | 2        |
+     *| ``.scope``                        | ``local``|
+     *
+ * + * Protobuf type {@code Mysqlx.Notice.SessionVariableChanged} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Notice.SessionVariableChanged) + com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChangedOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_SessionVariableChanged_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_SessionVariableChanged_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged.class, com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getValueFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + param_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + if (valueBuilder_ == null) { + value_ = null; + } else { + valueBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_SessionVariableChanged_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged build() { + com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged buildPartial() { + com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged result = new com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.param_ = param_; + if (((from_bitField0_ & 0x00000002) != 0)) { + if (valueBuilder_ == null) { + result.value_ = value_; + } else { + result.value_ = valueBuilder_.build(); + } + to_bitField0_ |= 0x00000002; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged other) { + if (other == com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged.getDefaultInstance()) return this; + if (other.hasParam()) { + bitField0_ |= 0x00000001; + param_ = other.param_; + onChanged(); + } + if (other.hasValue()) { + mergeValue(other.getValue()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasParam()) { + return false; + } + if (hasValue()) { + if (!getValue().isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object param_ = ""; + /** + * 
+       ** name of the variable 
+       *
+ * + * required string param = 1; + * @return Whether the param field is set. + */ + public boolean hasParam() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** name of the variable 
+       *
+ * + * required string param = 1; + * @return The param. + */ + public java.lang.String getParam() { + java.lang.Object ref = param_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + param_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * 
+       ** name of the variable 
+       *
+ * + * required string param = 1; + * @return The bytes for param. + */ + public com.google.protobuf.ByteString + getParamBytes() { + java.lang.Object ref = param_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + param_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * 
+       ** name of the variable 
+       *
+ * + * required string param = 1; + * @param value The param to set. + * @return This builder for chaining. + */ + public Builder setParam( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + param_ = value; + onChanged(); + return this; + } + /** + * 
+       ** name of the variable 
+       *
+ * + * required string param = 1; + * @return This builder for chaining. + */ + public Builder clearParam() { + bitField0_ = (bitField0_ & ~0x00000001); + param_ = getDefaultInstance().getParam(); + onChanged(); + return this; + } + /** + * 
+       ** name of the variable 
+       *
+ * + * required string param = 1; + * @param value The bytes for param to set. + * @return This builder for chaining. + */ + public Builder setParamBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + param_ = value; + onChanged(); + return this; + } + + private com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder> valueBuilder_; + /** + * 
+       ** the changed value of param 
+       *
+ * + * optional .Mysqlx.Datatypes.Scalar value = 2; + * @return Whether the value field is set. + */ + public boolean hasValue() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** the changed value of param 
+       *
+ * + * optional .Mysqlx.Datatypes.Scalar value = 2; + * @return The value. + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getValue() { + if (valueBuilder_ == null) { + return value_ == null ? com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance() : value_; + } else { + return valueBuilder_.getMessage(); + } + } + /** + * 
+       ** the changed value of param 
+       *
+ * + * optional .Mysqlx.Datatypes.Scalar value = 2; + */ + public Builder setValue(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value) { + if (valueBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + value_ = value; + onChanged(); + } else { + valueBuilder_.setMessage(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * 
+       ** the changed value of param 
+       *
+ * + * optional .Mysqlx.Datatypes.Scalar value = 2; + */ + public Builder setValue( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder builderForValue) { + if (valueBuilder_ == null) { + value_ = builderForValue.build(); + onChanged(); + } else { + valueBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * 
+       ** the changed value of param 
+       *
+ * + * optional .Mysqlx.Datatypes.Scalar value = 2; + */ + public Builder mergeValue(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value) { + if (valueBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0) && + value_ != null && + value_ != com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance()) { + value_ = + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.newBuilder(value_).mergeFrom(value).buildPartial(); + } else { + value_ = value; + } + onChanged(); + } else { + valueBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * 
+       ** the changed value of param 
+       *
+ * + * optional .Mysqlx.Datatypes.Scalar value = 2; + */ + public Builder clearValue() { + if (valueBuilder_ == null) { + value_ = null; + onChanged(); + } else { + valueBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + /** + * 
+       ** the changed value of param 
+       *
+ * + * optional .Mysqlx.Datatypes.Scalar value = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder getValueBuilder() { + bitField0_ |= 0x00000002; + onChanged(); + return getValueFieldBuilder().getBuilder(); + } + /** + * 
+       ** the changed value of param 
+       *
+ * + * optional .Mysqlx.Datatypes.Scalar value = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getValueOrBuilder() { + if (valueBuilder_ != null) { + return valueBuilder_.getMessageOrBuilder(); + } else { + return value_ == null ? + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance() : value_; + } + } + /** + * 
+       ** the changed value of param 
+       *
+ * + * optional .Mysqlx.Datatypes.Scalar value = 2; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder> + getValueFieldBuilder() { + if (valueBuilder_ == null) { + valueBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder>( + getValue(), + getParentForChildren(), + isClean()); + value_ = null; + } + return valueBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Notice.SessionVariableChanged) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Notice.SessionVariableChanged) + private static final com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged(); + } + + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public SessionVariableChanged parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new SessionVariableChanged(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.SessionVariableChanged getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface SessionStateChangedOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Notice.SessionStateChanged) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** parameter key 
+     *
+ * + * required .Mysqlx.Notice.SessionStateChanged.Parameter param = 1; + * @return Whether the param field is set. + */ + boolean hasParam(); + /** + * 
+     ** parameter key 
+     *
+ * + * required .Mysqlx.Notice.SessionStateChanged.Parameter param = 1; + * @return The param. + */ + com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged.Parameter getParam(); + + /** + * 
+     ** updated value 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + java.util.List + getValueList(); + /** + * 
+     ** updated value 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getValue(int index); + /** + * 
+     ** updated value 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + int getValueCount(); + /** + * 
+     ** updated value 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + java.util.List + getValueOrBuilderList(); + /** + * 
+     ** updated value 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getValueOrBuilder( + int index); + } + /** + * Protobuf type {@code Mysqlx.Notice.SessionStateChanged} + */ + public static final class SessionStateChanged extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Notice.SessionStateChanged) + SessionStateChangedOrBuilder { + private static final long serialVersionUID = 0L; + // Use SessionStateChanged.newBuilder() to construct. + private SessionStateChanged(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private SessionStateChanged() { + param_ = 1; + value_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new SessionStateChanged(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private SessionStateChanged( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged.Parameter value = com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged.Parameter.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(1, rawValue); + } else { + bitField0_ |= 0x00000001; + param_ = rawValue; + } + break; + } + case 18: { + if (!((mutable_bitField0_ & 0x00000002) != 0)) { + value_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000002; + } + value_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.PARSER, extensionRegistry)); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000002) != 0)) { + value_ = java.util.Collections.unmodifiableList(value_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_SessionStateChanged_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_SessionStateChanged_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged.class, com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged.Builder.class); + } + + /** + * Protobuf enum {@code Mysqlx.Notice.SessionStateChanged.Parameter} + */ + public enum Parameter + implements com.google.protobuf.ProtocolMessageEnum { + /** + * CURRENT_SCHEMA = 1; + */ + CURRENT_SCHEMA(1), + /** + * ACCOUNT_EXPIRED = 2; + */ + ACCOUNT_EXPIRED(2), + /** + * GENERATED_INSERT_ID = 3; + */ + GENERATED_INSERT_ID(3), + /** + * ROWS_AFFECTED = 4; + */ + ROWS_AFFECTED(4), + /** + * ROWS_FOUND = 5; + */ + ROWS_FOUND(5), + /** + * ROWS_MATCHED = 6; + */ + ROWS_MATCHED(6), + /** + * TRX_COMMITTED = 7; + */ + TRX_COMMITTED(7), + /** + * TRX_ROLLEDBACK = 9; + */ + TRX_ROLLEDBACK(9), + /** + * PRODUCED_MESSAGE = 10; + */ + PRODUCED_MESSAGE(10), + /** + * CLIENT_ID_ASSIGNED = 11; + */ + CLIENT_ID_ASSIGNED(11), + /** + * 
+       * .. more to be added
+       *
+ * + * GENERATED_DOCUMENT_IDS = 12; + */ + GENERATED_DOCUMENT_IDS(12), + ; + + /** + * CURRENT_SCHEMA = 1; + */ + public static final int CURRENT_SCHEMA_VALUE = 1; + /** + * ACCOUNT_EXPIRED = 2; + */ + public static final int ACCOUNT_EXPIRED_VALUE = 2; + /** + * GENERATED_INSERT_ID = 3; + */ + public static final int GENERATED_INSERT_ID_VALUE = 3; + /** + * ROWS_AFFECTED = 4; + */ + public static final int ROWS_AFFECTED_VALUE = 4; + /** + * ROWS_FOUND = 5; + */ + public static final int ROWS_FOUND_VALUE = 5; + /** + * ROWS_MATCHED = 6; + */ + public static final int ROWS_MATCHED_VALUE = 6; + /** + * TRX_COMMITTED = 7; + */ + public static final int TRX_COMMITTED_VALUE = 7; + /** + * TRX_ROLLEDBACK = 9; + */ + public static final int TRX_ROLLEDBACK_VALUE = 9; + /** + * PRODUCED_MESSAGE = 10; + */ + public static final int PRODUCED_MESSAGE_VALUE = 10; + /** + * CLIENT_ID_ASSIGNED = 11; + */ + public static final int CLIENT_ID_ASSIGNED_VALUE = 11; + /** + * 
+       * .. more to be added
+       *
+ * + * GENERATED_DOCUMENT_IDS = 12; + */ + public static final int GENERATED_DOCUMENT_IDS_VALUE = 12; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static Parameter valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static Parameter forNumber(int value) { + switch (value) { + case 1: return CURRENT_SCHEMA; + case 2: return ACCOUNT_EXPIRED; + case 3: return GENERATED_INSERT_ID; + case 4: return ROWS_AFFECTED; + case 5: return ROWS_FOUND; + case 6: return ROWS_MATCHED; + case 7: return TRX_COMMITTED; + case 9: return TRX_ROLLEDBACK; + case 10: return PRODUCED_MESSAGE; + case 11: return CLIENT_ID_ASSIGNED; + case 12: return GENERATED_DOCUMENT_IDS; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + Parameter> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Parameter findValueByNumber(int number) { + return Parameter.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged.getDescriptor().getEnumTypes().get(0); + } + + private static final Parameter[] VALUES = values(); + + public static Parameter valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private Parameter(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Notice.SessionStateChanged.Parameter) + } + + private int bitField0_; + public static final int PARAM_FIELD_NUMBER = 1; + private int param_; + /** + * 
+     ** parameter key 
+     *
+ * + * required .Mysqlx.Notice.SessionStateChanged.Parameter param = 1; + * @return Whether the param field is set. + */ + public boolean hasParam() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** parameter key 
+     *
+ * + * required .Mysqlx.Notice.SessionStateChanged.Parameter param = 1; + * @return The param. + */ + public com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged.Parameter getParam() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged.Parameter result = com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged.Parameter.valueOf(param_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged.Parameter.CURRENT_SCHEMA : result; + } + + public static final int VALUE_FIELD_NUMBER = 2; + private java.util.List value_; + /** + * 
+     ** updated value 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public java.util.List getValueList() { + return value_; + } + /** + * 
+     ** updated value 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public java.util.List + getValueOrBuilderList() { + return value_; + } + /** + * 
+     ** updated value 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public int getValueCount() { + return value_.size(); + } + /** + * 
+     ** updated value 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getValue(int index) { + return value_.get(index); + } + /** + * 
+     ** updated value 
+     *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getValueOrBuilder( + int index) { + return value_.get(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasParam()) { + memoizedIsInitialized = 0; + return false; + } + for (int i = 0; i < getValueCount(); i++) { + if (!getValue(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeEnum(1, param_); + } + for (int i = 0; i < value_.size(); i++) { + output.writeMessage(2, value_.get(i)); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(1, param_); + } + for (int i = 0; i < value_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, value_.get(i)); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged other = (com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged) obj; + + if (hasParam() != other.hasParam()) return false; + if (hasParam()) { + if (param_ != other.param_) return false; + } + if (!getValueList() + .equals(other.getValueList())) return false; + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasParam()) { + hash = (37 * hash) + PARAM_FIELD_NUMBER; + hash = (53 * hash) + param_; + } + if (getValueCount() > 0) { + hash = (37 * hash) + VALUE_FIELD_NUMBER; + hash = (53 * hash) + getValueList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Mysqlx.Notice.SessionStateChanged} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Notice.SessionStateChanged) + com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChangedOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_SessionStateChanged_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_SessionStateChanged_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged.class, com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getValueFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + param_ = 1; + bitField0_ = (bitField0_ & ~0x00000001); + if (valueBuilder_ == null) { + value_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + } else { + valueBuilder_.clear(); + } + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_SessionStateChanged_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged build() { + com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged buildPartial() { + com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged result = new com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.param_ = param_; + if (valueBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0)) { + value_ = java.util.Collections.unmodifiableList(value_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.value_ = value_; + } else { + result.value_ = valueBuilder_.build(); + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged other) { + if (other == com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged.getDefaultInstance()) return this; + if (other.hasParam()) { + setParam(other.getParam()); + } + if (valueBuilder_ == null) { + if (!other.value_.isEmpty()) { + if (value_.isEmpty()) { + value_ = other.value_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureValueIsMutable(); + value_.addAll(other.value_); + } + onChanged(); + } + } else { + if (!other.value_.isEmpty()) { + if (valueBuilder_.isEmpty()) { + valueBuilder_.dispose(); + valueBuilder_ = null; + value_ = other.value_; + bitField0_ = (bitField0_ & ~0x00000002); + valueBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getValueFieldBuilder() : null; + } else { + valueBuilder_.addAllMessages(other.value_); + } + } + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasParam()) { + return false; + } + for (int i = 0; i < getValueCount(); i++) { + if (!getValue(i).isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int param_ = 1; + /** + * 
+       ** parameter key 
+       *
+ * + * required .Mysqlx.Notice.SessionStateChanged.Parameter param = 1; + * @return Whether the param field is set. + */ + public boolean hasParam() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** parameter key 
+       *
+ * + * required .Mysqlx.Notice.SessionStateChanged.Parameter param = 1; + * @return The param. + */ + public com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged.Parameter getParam() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged.Parameter result = com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged.Parameter.valueOf(param_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged.Parameter.CURRENT_SCHEMA : result; + } + /** + * 
+       ** parameter key 
+       *
+ * + * required .Mysqlx.Notice.SessionStateChanged.Parameter param = 1; + * @param value The param to set. + * @return This builder for chaining. + */ + public Builder setParam(com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged.Parameter value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + param_ = value.getNumber(); + onChanged(); + return this; + } + /** + * 
+       ** parameter key 
+       *
+ * + * required .Mysqlx.Notice.SessionStateChanged.Parameter param = 1; + * @return This builder for chaining. + */ + public Builder clearParam() { + bitField0_ = (bitField0_ & ~0x00000001); + param_ = 1; + onChanged(); + return this; + } + + private java.util.List value_ = + java.util.Collections.emptyList(); + private void ensureValueIsMutable() { + if (!((bitField0_ & 0x00000002) != 0)) { + value_ = new java.util.ArrayList(value_); + bitField0_ |= 0x00000002; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder> valueBuilder_; + + /** + * 
+       ** updated value 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public java.util.List getValueList() { + if (valueBuilder_ == null) { + return java.util.Collections.unmodifiableList(value_); + } else { + return valueBuilder_.getMessageList(); + } + } + /** + * 
+       ** updated value 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public int getValueCount() { + if (valueBuilder_ == null) { + return value_.size(); + } else { + return valueBuilder_.getCount(); + } + } + /** + * 
+       ** updated value 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar getValue(int index) { + if (valueBuilder_ == null) { + return value_.get(index); + } else { + return valueBuilder_.getMessage(index); + } + } + /** + * 
+       ** updated value 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public Builder setValue( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value) { + if (valueBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureValueIsMutable(); + value_.set(index, value); + onChanged(); + } else { + valueBuilder_.setMessage(index, value); + } + return this; + } + /** + * 
+       ** updated value 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public Builder setValue( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder builderForValue) { + if (valueBuilder_ == null) { + ensureValueIsMutable(); + value_.set(index, builderForValue.build()); + onChanged(); + } else { + valueBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** updated value 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public Builder addValue(com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value) { + if (valueBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureValueIsMutable(); + value_.add(value); + onChanged(); + } else { + valueBuilder_.addMessage(value); + } + return this; + } + /** + * 
+       ** updated value 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public Builder addValue( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar value) { + if (valueBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureValueIsMutable(); + value_.add(index, value); + onChanged(); + } else { + valueBuilder_.addMessage(index, value); + } + return this; + } + /** + * 
+       ** updated value 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public Builder addValue( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder builderForValue) { + if (valueBuilder_ == null) { + ensureValueIsMutable(); + value_.add(builderForValue.build()); + onChanged(); + } else { + valueBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * 
+       ** updated value 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public Builder addValue( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder builderForValue) { + if (valueBuilder_ == null) { + ensureValueIsMutable(); + value_.add(index, builderForValue.build()); + onChanged(); + } else { + valueBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** updated value 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public Builder addAllValue( + java.lang.Iterable values) { + if (valueBuilder_ == null) { + ensureValueIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, value_); + onChanged(); + } else { + valueBuilder_.addAllMessages(values); + } + return this; + } + /** + * 
+       ** updated value 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public Builder clearValue() { + if (valueBuilder_ == null) { + value_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + } else { + valueBuilder_.clear(); + } + return this; + } + /** + * 
+       ** updated value 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public Builder removeValue(int index) { + if (valueBuilder_ == null) { + ensureValueIsMutable(); + value_.remove(index); + onChanged(); + } else { + valueBuilder_.remove(index); + } + return this; + } + /** + * 
+       ** updated value 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder getValueBuilder( + int index) { + return getValueFieldBuilder().getBuilder(index); + } + /** + * 
+       ** updated value 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder getValueOrBuilder( + int index) { + if (valueBuilder_ == null) { + return value_.get(index); } else { + return valueBuilder_.getMessageOrBuilder(index); + } + } + /** + * 
+       ** updated value 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public java.util.List + getValueOrBuilderList() { + if (valueBuilder_ != null) { + return valueBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(value_); + } + } + /** + * 
+       ** updated value 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder addValueBuilder() { + return getValueFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance()); + } + /** + * 
+       ** updated value 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder addValueBuilder( + int index) { + return getValueFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.getDefaultInstance()); + } + /** + * 
+       ** updated value 
+       *
+ * + * repeated .Mysqlx.Datatypes.Scalar value = 2; + */ + public java.util.List + getValueBuilderList() { + return getValueFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder> + getValueFieldBuilder() { + if (valueBuilder_ == null) { + valueBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar, com.mysql.cj.x.protobuf.MysqlxDatatypes.Scalar.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.ScalarOrBuilder>( + value_, + ((bitField0_ & 0x00000002) != 0), + getParentForChildren(), + isClean()); + value_ = null; + } + return valueBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Notice.SessionStateChanged) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Notice.SessionStateChanged) + private static final com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged(); + } + + public static com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public SessionStateChanged parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new SessionStateChanged(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.SessionStateChanged getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface GroupReplicationStateChangedOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Notice.GroupReplicationStateChanged) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** type of group replication event 
+     *
+ * + * required uint32 type = 1; + * @return Whether the type field is set. + */ + boolean hasType(); + /** + * 
+     ** type of group replication event 
+     *
+ * + * required uint32 type = 1; + * @return The type. + */ + int getType(); + + /** + * 
+     ** view identifier 
+     *
+ * + * optional string view_id = 2; + * @return Whether the viewId field is set. + */ + boolean hasViewId(); + /** + * 
+     ** view identifier 
+     *
+ * + * optional string view_id = 2; + * @return The viewId. + */ + java.lang.String getViewId(); + /** + * 
+     ** view identifier 
+     *
+ * + * optional string view_id = 2; + * @return The bytes for viewId. + */ + com.google.protobuf.ByteString + getViewIdBytes(); + } + /** + * 
+   **
+   *Notify clients about group replication state changes
+   *| @ref Mysqlx::Notice::Frame Field  | Value      |
+   *|-----------------------------------|------------|
+   *|``.type``                          | 4          |
+   *|``.scope``                         | ``global`` |
+   *
+ * + * Protobuf type {@code Mysqlx.Notice.GroupReplicationStateChanged} + */ + public static final class GroupReplicationStateChanged extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Notice.GroupReplicationStateChanged) + GroupReplicationStateChangedOrBuilder { + private static final long serialVersionUID = 0L; + // Use GroupReplicationStateChanged.newBuilder() to construct. + private GroupReplicationStateChanged(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private GroupReplicationStateChanged() { + viewId_ = ""; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new GroupReplicationStateChanged(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private GroupReplicationStateChanged( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + bitField0_ |= 0x00000001; + type_ = input.readUInt32(); + break; + } + case 18: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000002; + viewId_ = bs; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_GroupReplicationStateChanged_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_GroupReplicationStateChanged_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged.class, com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged.Builder.class); + } + + /** + * Protobuf enum {@code Mysqlx.Notice.GroupReplicationStateChanged.Type} + */ + public enum Type + implements com.google.protobuf.ProtocolMessageEnum { + /** + * MEMBERSHIP_QUORUM_LOSS = 1; + */ + MEMBERSHIP_QUORUM_LOSS(1), + /** + * MEMBERSHIP_VIEW_CHANGE = 2; + */ + MEMBERSHIP_VIEW_CHANGE(2), + /** + * MEMBER_ROLE_CHANGE = 3; + */ + MEMBER_ROLE_CHANGE(3), + /** + * MEMBER_STATE_CHANGE = 4; + */ + MEMBER_STATE_CHANGE(4), + ; + + /** + * MEMBERSHIP_QUORUM_LOSS = 1; + */ + public static final int MEMBERSHIP_QUORUM_LOSS_VALUE = 1; + /** + * MEMBERSHIP_VIEW_CHANGE = 2; + */ + public static final int MEMBERSHIP_VIEW_CHANGE_VALUE = 2; + /** + * MEMBER_ROLE_CHANGE = 3; + */ + public static final int MEMBER_ROLE_CHANGE_VALUE = 3; + /** + * MEMBER_STATE_CHANGE = 4; + */ + public static final int MEMBER_STATE_CHANGE_VALUE = 4; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static Type valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static Type forNumber(int value) { + switch (value) { + case 1: return MEMBERSHIP_QUORUM_LOSS; + case 2: return MEMBERSHIP_VIEW_CHANGE; + case 3: return MEMBER_ROLE_CHANGE; + case 4: return MEMBER_STATE_CHANGE; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + Type> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Type findValueByNumber(int number) { + return Type.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged.getDescriptor().getEnumTypes().get(0); + } + + private static final Type[] VALUES = values(); + + public static Type valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private Type(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Notice.GroupReplicationStateChanged.Type) + } + + private int bitField0_; + public static final int TYPE_FIELD_NUMBER = 1; + private int type_; + /** + * 
+     ** type of group replication event 
+     *
+ * + * required uint32 type = 1; + * @return Whether the type field is set. + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** type of group replication event 
+     *
+ * + * required uint32 type = 1; + * @return The type. + */ + public int getType() { + return type_; + } + + public static final int VIEW_ID_FIELD_NUMBER = 2; + private volatile java.lang.Object viewId_; + /** + * 
+     ** view identifier 
+     *
+ * + * optional string view_id = 2; + * @return Whether the viewId field is set. + */ + public boolean hasViewId() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** view identifier 
+     *
+ * + * optional string view_id = 2; + * @return The viewId. + */ + public java.lang.String getViewId() { + java.lang.Object ref = viewId_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + viewId_ = s; + } + return s; + } + } + /** + * 
+     ** view identifier 
+     *
+ * + * optional string view_id = 2; + * @return The bytes for viewId. + */ + public com.google.protobuf.ByteString + getViewIdBytes() { + java.lang.Object ref = viewId_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + viewId_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasType()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeUInt32(1, type_); + } + if (((bitField0_ & 0x00000002) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 2, viewId_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(1, type_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(2, viewId_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged other = (com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged) obj; + + if (hasType() != other.hasType()) return false; + if (hasType()) { + if (getType() + != other.getType()) return false; + } + if (hasViewId() != other.hasViewId()) return false; + if (hasViewId()) { + if (!getViewId() + .equals(other.getViewId())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasType()) { + hash = (37 * hash) + TYPE_FIELD_NUMBER; + hash = (53 * hash) + getType(); + } + if (hasViewId()) { + hash = (37 * hash) + VIEW_ID_FIELD_NUMBER; + hash = (53 * hash) + getViewId().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Notify clients about group replication state changes
+     *| @ref Mysqlx::Notice::Frame Field  | Value      |
+     *|-----------------------------------|------------|
+     *|``.type``                          | 4          |
+     *|``.scope``                         | ``global`` |
+     *
+ * + * Protobuf type {@code Mysqlx.Notice.GroupReplicationStateChanged} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Notice.GroupReplicationStateChanged) + com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChangedOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_GroupReplicationStateChanged_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_GroupReplicationStateChanged_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged.class, com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + type_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + viewId_ = ""; + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_GroupReplicationStateChanged_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged build() { + com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged buildPartial() { + com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged result = new com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.type_ = type_; + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + to_bitField0_ |= 0x00000002; + } + result.viewId_ = viewId_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged other) { + if (other == com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged.getDefaultInstance()) return this; + if (other.hasType()) { + setType(other.getType()); + } + if (other.hasViewId()) { + bitField0_ |= 0x00000002; + viewId_ = other.viewId_; + onChanged(); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasType()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int type_ ; + /** + * 
+       ** type of group replication event 
+       *
+ * + * required uint32 type = 1; + * @return Whether the type field is set. + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** type of group replication event 
+       *
+ * + * required uint32 type = 1; + * @return The type. + */ + public int getType() { + return type_; + } + /** + * 
+       ** type of group replication event 
+       *
+ * + * required uint32 type = 1; + * @param value The type to set. + * @return This builder for chaining. + */ + public Builder setType(int value) { + bitField0_ |= 0x00000001; + type_ = value; + onChanged(); + return this; + } + /** + * 
+       ** type of group replication event 
+       *
+ * + * required uint32 type = 1; + * @return This builder for chaining. + */ + public Builder clearType() { + bitField0_ = (bitField0_ & ~0x00000001); + type_ = 0; + onChanged(); + return this; + } + + private java.lang.Object viewId_ = ""; + /** + * 
+       ** view identifier 
+       *
+ * + * optional string view_id = 2; + * @return Whether the viewId field is set. + */ + public boolean hasViewId() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** view identifier 
+       *
+ * + * optional string view_id = 2; + * @return The viewId. + */ + public java.lang.String getViewId() { + java.lang.Object ref = viewId_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + viewId_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * 
+       ** view identifier 
+       *
+ * + * optional string view_id = 2; + * @return The bytes for viewId. + */ + public com.google.protobuf.ByteString + getViewIdBytes() { + java.lang.Object ref = viewId_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + viewId_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * 
+       ** view identifier 
+       *
+ * + * optional string view_id = 2; + * @param value The viewId to set. + * @return This builder for chaining. + */ + public Builder setViewId( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + viewId_ = value; + onChanged(); + return this; + } + /** + * 
+       ** view identifier 
+       *
+ * + * optional string view_id = 2; + * @return This builder for chaining. + */ + public Builder clearViewId() { + bitField0_ = (bitField0_ & ~0x00000002); + viewId_ = getDefaultInstance().getViewId(); + onChanged(); + return this; + } + /** + * 
+       ** view identifier 
+       *
+ * + * optional string view_id = 2; + * @param value The bytes for viewId to set. + * @return This builder for chaining. + */ + public Builder setViewIdBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + viewId_ = value; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Notice.GroupReplicationStateChanged) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Notice.GroupReplicationStateChanged) + private static final com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged(); + } + + public static com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public GroupReplicationStateChanged parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new GroupReplicationStateChanged(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.GroupReplicationStateChanged getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ServerHelloOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Notice.ServerHello) + com.google.protobuf.MessageOrBuilder { + } + /** + * 
+   **
+   *Notify clients about connection to X Protocol server
+   *| @ref Mysqlx::Notice::Frame Field  | Value      |
+   *|-----------------------------------|------------|
+   *|``.type``                          | 5          |
+   *|``.scope``                         | ``global`` |
+   *
+ * + * Protobuf type {@code Mysqlx.Notice.ServerHello} + */ + public static final class ServerHello extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Notice.ServerHello) + ServerHelloOrBuilder { + private static final long serialVersionUID = 0L; + // Use ServerHello.newBuilder() to construct. + private ServerHello(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private ServerHello() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new ServerHello(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private ServerHello( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_ServerHello_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_ServerHello_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello.class, com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello.Builder.class); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello other = (com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello) obj; + + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Notify clients about connection to X Protocol server
+     *| @ref Mysqlx::Notice::Frame Field  | Value      |
+     *|-----------------------------------|------------|
+     *|``.type``                          | 5          |
+     *|``.scope``                         | ``global`` |
+     *
+ * + * Protobuf type {@code Mysqlx.Notice.ServerHello} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Notice.ServerHello) + com.mysql.cj.x.protobuf.MysqlxNotice.ServerHelloOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_ServerHello_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_ServerHello_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello.class, com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxNotice.internal_static_Mysqlx_Notice_ServerHello_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello build() { + com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello buildPartial() { + com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello result = new com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello(this); + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello other) { + if (other == com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello.getDefaultInstance()) return this; + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Notice.ServerHello) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Notice.ServerHello) + private static final com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello(); + } + + public static com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public ServerHello parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new ServerHello(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxNotice.ServerHello getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Notice_Frame_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Notice_Frame_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Notice_Warning_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Notice_Warning_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Notice_SessionVariableChanged_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Notice_SessionVariableChanged_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Notice_SessionStateChanged_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Notice_SessionStateChanged_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Notice_GroupReplicationStateChanged_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Notice_GroupReplicationStateChanged_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Notice_ServerHello_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Notice_ServerHello_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\023mysqlx_notice.proto\022\rMysqlx.Notice\032\014my" + + "sqlx.proto\032\026mysqlx_datatypes.proto\"\205\002\n\005F" + + "rame\022\014\n\004type\030\001 \002(\r\0221\n\005scope\030\002 \001(\0162\032.Mysq" + + "lx.Notice.Frame.Scope:\006GLOBAL\022\017\n\007payload" + + "\030\003 \001(\014\"\036\n\005Scope\022\n\n\006GLOBAL\020\001\022\t\n\005LOCAL\020\002\"\203" + + "\001\n\004Type\022\013\n\007WARNING\020\001\022\034\n\030SESSION_VARIABLE" + + "_CHANGED\020\002\022\031\n\025SESSION_STATE_CHANGED\020\003\022#\n" + + "\037GROUP_REPLICATION_STATE_CHANGED\020\004\022\020\n\014SE" + + "RVER_HELLO\020\005:\004\220\3520\013\"\205\001\n\007Warning\0224\n\005level\030" + + "\001 \001(\0162\034.Mysqlx.Notice.Warning.Level:\007WAR" + + "NING\022\014\n\004code\030\002 \002(\r\022\013\n\003msg\030\003 \002(\t\")\n\005Level" + + "\022\010\n\004NOTE\020\001\022\013\n\007WARNING\020\002\022\t\n\005ERROR\020\003\"P\n\026Se" + + "ssionVariableChanged\022\r\n\005param\030\001 \002(\t\022\'\n\005v" + + "alue\030\002 \001(\0132\030.Mysqlx.Datatypes.Scalar\"\361\002\n" + + "\023SessionStateChanged\022;\n\005param\030\001 \002(\0162,.My" + + "sqlx.Notice.SessionStateChanged.Paramete" + + "r\022\'\n\005value\030\002 \003(\0132\030.Mysqlx.Datatypes.Scal" + + "ar\"\363\001\n\tParameter\022\022\n\016CURRENT_SCHEMA\020\001\022\023\n\017" + + "ACCOUNT_EXPIRED\020\002\022\027\n\023GENERATED_INSERT_ID" + + "\020\003\022\021\n\rROWS_AFFECTED\020\004\022\016\n\nROWS_FOUND\020\005\022\020\n" + + "\014ROWS_MATCHED\020\006\022\021\n\rTRX_COMMITTED\020\007\022\022\n\016TR" + + "X_ROLLEDBACK\020\t\022\024\n\020PRODUCED_MESSAGE\020\n\022\026\n\022" + + "CLIENT_ID_ASSIGNED\020\013\022\032\n\026GENERATED_DOCUME" + + "NT_IDS\020\014\"\256\001\n\034GroupReplicationStateChange" + + "d\022\014\n\004type\030\001 \002(\r\022\017\n\007view_id\030\002 \001(\t\"o\n\004Type" + + "\022\032\n\026MEMBERSHIP_QUORUM_LOSS\020\001\022\032\n\026MEMBERSH" + + "IP_VIEW_CHANGE\020\002\022\026\n\022MEMBER_ROLE_CHANGE\020\003" + + "\022\027\n\023MEMBER_STATE_CHANGE\020\004\"\r\n\013ServerHello" + + "B\031\n\027com.mysql.cj.x.protobuf" + }; + descriptor = com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + com.mysql.cj.x.protobuf.Mysqlx.getDescriptor(), + com.mysql.cj.x.protobuf.MysqlxDatatypes.getDescriptor(), + }); + internal_static_Mysqlx_Notice_Frame_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_Mysqlx_Notice_Frame_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Notice_Frame_descriptor, + new java.lang.String[] { "Type", "Scope", "Payload", }); + internal_static_Mysqlx_Notice_Warning_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_Mysqlx_Notice_Warning_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Notice_Warning_descriptor, + new java.lang.String[] { "Level", "Code", "Msg", }); + internal_static_Mysqlx_Notice_SessionVariableChanged_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_Mysqlx_Notice_SessionVariableChanged_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Notice_SessionVariableChanged_descriptor, + new java.lang.String[] { "Param", "Value", }); + internal_static_Mysqlx_Notice_SessionStateChanged_descriptor = + getDescriptor().getMessageTypes().get(3); + internal_static_Mysqlx_Notice_SessionStateChanged_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Notice_SessionStateChanged_descriptor, + new java.lang.String[] { "Param", "Value", }); + internal_static_Mysqlx_Notice_GroupReplicationStateChanged_descriptor = + getDescriptor().getMessageTypes().get(4); + internal_static_Mysqlx_Notice_GroupReplicationStateChanged_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Notice_GroupReplicationStateChanged_descriptor, + new java.lang.String[] { "Type", "ViewId", }); + internal_static_Mysqlx_Notice_ServerHello_descriptor = + getDescriptor().getMessageTypes().get(5); + internal_static_Mysqlx_Notice_ServerHello_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Notice_ServerHello_descriptor, + new java.lang.String[] { }); + com.google.protobuf.ExtensionRegistry registry = + com.google.protobuf.ExtensionRegistry.newInstance(); + registry.add(com.mysql.cj.x.protobuf.Mysqlx.serverMessageId); + com.google.protobuf.Descriptors.FileDescriptor + .internalUpdateFileDescriptor(descriptor, registry); + com.mysql.cj.x.protobuf.Mysqlx.getDescriptor(); + com.mysql.cj.x.protobuf.MysqlxDatatypes.getDescriptor(); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxPrepare.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxPrepare.java new file mode 100644 index 0000000..b7c42d5 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxPrepare.java @@ -0,0 +1,4575 @@ +/* + * Copyright (c) 2019, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.x.protobuf; + +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: mysqlx_prepare.proto + +@SuppressWarnings({ "deprecation" }) +public final class MysqlxPrepare { + private MysqlxPrepare() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + public interface PrepareOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Prepare.Prepare) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** client side assigned statement id, which is going to identify
+     *the result of preparation 
+     *
+ * + * required uint32 stmt_id = 1; + * @return Whether the stmtId field is set. + */ + boolean hasStmtId(); + /** + * 
+     ** client side assigned statement id, which is going to identify
+     *the result of preparation 
+     *
+ * + * required uint32 stmt_id = 1; + * @return The stmtId. + */ + int getStmtId(); + + /** + * 
+     ** defines one of following messages to be prepared:
+     *Crud::Find, Crud::Insert, Crud::Delete, Crud::Upsert, Sql::StmtExecute 
+     *
+ * + * required .Mysqlx.Prepare.Prepare.OneOfMessage stmt = 2; + * @return Whether the stmt field is set. + */ + boolean hasStmt(); + /** + * 
+     ** defines one of following messages to be prepared:
+     *Crud::Find, Crud::Insert, Crud::Delete, Crud::Upsert, Sql::StmtExecute 
+     *
+ * + * required .Mysqlx.Prepare.Prepare.OneOfMessage stmt = 2; + * @return The stmt. + */ + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage getStmt(); + /** + * 
+     ** defines one of following messages to be prepared:
+     *Crud::Find, Crud::Insert, Crud::Delete, Crud::Upsert, Sql::StmtExecute 
+     *
+ * + * required .Mysqlx.Prepare.Prepare.OneOfMessage stmt = 2; + */ + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessageOrBuilder getStmtOrBuilder(); + } + /** + * 
+   **
+   *Prepare a new statement
+   *@startuml
+   *client -> server: Prepare
+   *alt Success
+   *client <- server: Ok
+   *else Failure
+   *client <- server: Error
+   *end
+   *@enduml
+   *@returns @ref Mysqlx::Ok or @ref Mysqlx::Error
+   *
+ * + * Protobuf type {@code Mysqlx.Prepare.Prepare} + */ + public static final class Prepare extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Prepare.Prepare) + PrepareOrBuilder { + private static final long serialVersionUID = 0L; + // Use Prepare.newBuilder() to construct. + private Prepare(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Prepare() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Prepare(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Prepare( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + bitField0_ |= 0x00000001; + stmtId_ = input.readUInt32(); + break; + } + case 18: { + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) != 0)) { + subBuilder = stmt_.toBuilder(); + } + stmt_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(stmt_); + stmt_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.internal_static_Mysqlx_Prepare_Prepare_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.internal_static_Mysqlx_Prepare_Prepare_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.class, com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.Builder.class); + } + + public interface OneOfMessageOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Prepare.Prepare.OneOfMessage) + com.google.protobuf.MessageOrBuilder { + + /** + * required .Mysqlx.Prepare.Prepare.OneOfMessage.Type type = 1; + * @return Whether the type field is set. + */ + boolean hasType(); + /** + * required .Mysqlx.Prepare.Prepare.OneOfMessage.Type type = 1; + * @return The type. + */ + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.Type getType(); + + /** + * optional .Mysqlx.Crud.Find find = 2; + * @return Whether the find field is set. + */ + boolean hasFind(); + /** + * optional .Mysqlx.Crud.Find find = 2; + * @return The find. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Find getFind(); + /** + * optional .Mysqlx.Crud.Find find = 2; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.FindOrBuilder getFindOrBuilder(); + + /** + * optional .Mysqlx.Crud.Insert insert = 3; + * @return Whether the insert field is set. + */ + boolean hasInsert(); + /** + * optional .Mysqlx.Crud.Insert insert = 3; + * @return The insert. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Insert getInsert(); + /** + * optional .Mysqlx.Crud.Insert insert = 3; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.InsertOrBuilder getInsertOrBuilder(); + + /** + * optional .Mysqlx.Crud.Update update = 4; + * @return Whether the update field is set. + */ + boolean hasUpdate(); + /** + * optional .Mysqlx.Crud.Update update = 4; + * @return The update. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Update getUpdate(); + /** + * optional .Mysqlx.Crud.Update update = 4; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOrBuilder getUpdateOrBuilder(); + + /** + * optional .Mysqlx.Crud.Delete delete = 5; + * @return Whether the delete field is set. + */ + boolean hasDelete(); + /** + * optional .Mysqlx.Crud.Delete delete = 5; + * @return The delete. + */ + com.mysql.cj.x.protobuf.MysqlxCrud.Delete getDelete(); + /** + * optional .Mysqlx.Crud.Delete delete = 5; + */ + com.mysql.cj.x.protobuf.MysqlxCrud.DeleteOrBuilder getDeleteOrBuilder(); + + /** + * optional .Mysqlx.Sql.StmtExecute stmt_execute = 6; + * @return Whether the stmtExecute field is set. + */ + boolean hasStmtExecute(); + /** + * optional .Mysqlx.Sql.StmtExecute stmt_execute = 6; + * @return The stmtExecute. + */ + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute getStmtExecute(); + /** + * optional .Mysqlx.Sql.StmtExecute stmt_execute = 6; + */ + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOrBuilder getStmtExecuteOrBuilder(); + } + /** + * Protobuf type {@code Mysqlx.Prepare.Prepare.OneOfMessage} + */ + public static final class OneOfMessage extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Prepare.Prepare.OneOfMessage) + OneOfMessageOrBuilder { + private static final long serialVersionUID = 0L; + // Use OneOfMessage.newBuilder() to construct. + private OneOfMessage(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private OneOfMessage() { + type_ = 0; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new OneOfMessage(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private OneOfMessage( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.Type value = com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.Type.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(1, rawValue); + } else { + bitField0_ |= 0x00000001; + type_ = rawValue; + } + break; + } + case 18: { + com.mysql.cj.x.protobuf.MysqlxCrud.Find.Builder subBuilder = null; + if (((bitField0_ & 0x00000002) != 0)) { + subBuilder = find_.toBuilder(); + } + find_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Find.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(find_); + find_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000002; + break; + } + case 26: { + com.mysql.cj.x.protobuf.MysqlxCrud.Insert.Builder subBuilder = null; + if (((bitField0_ & 0x00000004) != 0)) { + subBuilder = insert_.toBuilder(); + } + insert_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Insert.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(insert_); + insert_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000004; + break; + } + case 34: { + com.mysql.cj.x.protobuf.MysqlxCrud.Update.Builder subBuilder = null; + if (((bitField0_ & 0x00000008) != 0)) { + subBuilder = update_.toBuilder(); + } + update_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Update.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(update_); + update_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000008; + break; + } + case 42: { + com.mysql.cj.x.protobuf.MysqlxCrud.Delete.Builder subBuilder = null; + if (((bitField0_ & 0x00000010) != 0)) { + subBuilder = delete_.toBuilder(); + } + delete_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxCrud.Delete.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(delete_); + delete_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000010; + break; + } + case 50: { + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute.Builder subBuilder = null; + if (((bitField0_ & 0x00000020) != 0)) { + subBuilder = stmtExecute_.toBuilder(); + } + stmtExecute_ = input.readMessage(com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute.PARSER, extensionRegistry); + if (subBuilder != null) { + subBuilder.mergeFrom(stmtExecute_); + stmtExecute_ = subBuilder.buildPartial(); + } + bitField0_ |= 0x00000020; + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.internal_static_Mysqlx_Prepare_Prepare_OneOfMessage_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.internal_static_Mysqlx_Prepare_Prepare_OneOfMessage_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.class, com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.Builder.class); + } + + /** + * 
+       * Determine which of optional fields was set by the client
+       * (Workaround for missing "oneof" keyword in pb2.5)
+       *
+ * + * Protobuf enum {@code Mysqlx.Prepare.Prepare.OneOfMessage.Type} + */ + public enum Type + implements com.google.protobuf.ProtocolMessageEnum { + /** + * FIND = 0; + */ + FIND(0), + /** + * INSERT = 1; + */ + INSERT(1), + /** + * UPDATE = 2; + */ + UPDATE(2), + /** + * DELETE = 4; + */ + DELETE(4), + /** + * STMT = 5; + */ + STMT(5), + ; + + /** + * FIND = 0; + */ + public static final int FIND_VALUE = 0; + /** + * INSERT = 1; + */ + public static final int INSERT_VALUE = 1; + /** + * UPDATE = 2; + */ + public static final int UPDATE_VALUE = 2; + /** + * DELETE = 4; + */ + public static final int DELETE_VALUE = 4; + /** + * STMT = 5; + */ + public static final int STMT_VALUE = 5; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static Type valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static Type forNumber(int value) { + switch (value) { + case 0: return FIND; + case 1: return INSERT; + case 2: return UPDATE; + case 4: return DELETE; + case 5: return STMT; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + Type> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public Type findValueByNumber(int number) { + return Type.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.getDescriptor().getEnumTypes().get(0); + } + + private static final Type[] VALUES = values(); + + public static Type valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private Type(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Prepare.Prepare.OneOfMessage.Type) + } + + private int bitField0_; + public static final int TYPE_FIELD_NUMBER = 1; + private int type_; + /** + * required .Mysqlx.Prepare.Prepare.OneOfMessage.Type type = 1; + * @return Whether the type field is set. + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required .Mysqlx.Prepare.Prepare.OneOfMessage.Type type = 1; + * @return The type. + */ + public com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.Type getType() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.Type result = com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.Type.valueOf(type_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.Type.FIND : result; + } + + public static final int FIND_FIELD_NUMBER = 2; + private com.mysql.cj.x.protobuf.MysqlxCrud.Find find_; + /** + * optional .Mysqlx.Crud.Find find = 2; + * @return Whether the find field is set. + */ + public boolean hasFind() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional .Mysqlx.Crud.Find find = 2; + * @return The find. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Find getFind() { + return find_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Find.getDefaultInstance() : find_; + } + /** + * optional .Mysqlx.Crud.Find find = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.FindOrBuilder getFindOrBuilder() { + return find_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Find.getDefaultInstance() : find_; + } + + public static final int INSERT_FIELD_NUMBER = 3; + private com.mysql.cj.x.protobuf.MysqlxCrud.Insert insert_; + /** + * optional .Mysqlx.Crud.Insert insert = 3; + * @return Whether the insert field is set. + */ + public boolean hasInsert() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * optional .Mysqlx.Crud.Insert insert = 3; + * @return The insert. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Insert getInsert() { + return insert_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Insert.getDefaultInstance() : insert_; + } + /** + * optional .Mysqlx.Crud.Insert insert = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.InsertOrBuilder getInsertOrBuilder() { + return insert_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Insert.getDefaultInstance() : insert_; + } + + public static final int UPDATE_FIELD_NUMBER = 4; + private com.mysql.cj.x.protobuf.MysqlxCrud.Update update_; + /** + * optional .Mysqlx.Crud.Update update = 4; + * @return Whether the update field is set. + */ + public boolean hasUpdate() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * optional .Mysqlx.Crud.Update update = 4; + * @return The update. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Update getUpdate() { + return update_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Update.getDefaultInstance() : update_; + } + /** + * optional .Mysqlx.Crud.Update update = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOrBuilder getUpdateOrBuilder() { + return update_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Update.getDefaultInstance() : update_; + } + + public static final int DELETE_FIELD_NUMBER = 5; + private com.mysql.cj.x.protobuf.MysqlxCrud.Delete delete_; + /** + * optional .Mysqlx.Crud.Delete delete = 5; + * @return Whether the delete field is set. + */ + public boolean hasDelete() { + return ((bitField0_ & 0x00000010) != 0); + } + /** + * optional .Mysqlx.Crud.Delete delete = 5; + * @return The delete. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Delete getDelete() { + return delete_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Delete.getDefaultInstance() : delete_; + } + /** + * optional .Mysqlx.Crud.Delete delete = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.DeleteOrBuilder getDeleteOrBuilder() { + return delete_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Delete.getDefaultInstance() : delete_; + } + + public static final int STMT_EXECUTE_FIELD_NUMBER = 6; + private com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute stmtExecute_; + /** + * optional .Mysqlx.Sql.StmtExecute stmt_execute = 6; + * @return Whether the stmtExecute field is set. + */ + public boolean hasStmtExecute() { + return ((bitField0_ & 0x00000020) != 0); + } + /** + * optional .Mysqlx.Sql.StmtExecute stmt_execute = 6; + * @return The stmtExecute. + */ + public com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute getStmtExecute() { + return stmtExecute_ == null ? com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute.getDefaultInstance() : stmtExecute_; + } + /** + * optional .Mysqlx.Sql.StmtExecute stmt_execute = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOrBuilder getStmtExecuteOrBuilder() { + return stmtExecute_ == null ? com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute.getDefaultInstance() : stmtExecute_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasType()) { + memoizedIsInitialized = 0; + return false; + } + if (hasFind()) { + if (!getFind().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasInsert()) { + if (!getInsert().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasUpdate()) { + if (!getUpdate().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasDelete()) { + if (!getDelete().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + if (hasStmtExecute()) { + if (!getStmtExecute().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeEnum(1, type_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeMessage(2, getFind()); + } + if (((bitField0_ & 0x00000004) != 0)) { + output.writeMessage(3, getInsert()); + } + if (((bitField0_ & 0x00000008) != 0)) { + output.writeMessage(4, getUpdate()); + } + if (((bitField0_ & 0x00000010) != 0)) { + output.writeMessage(5, getDelete()); + } + if (((bitField0_ & 0x00000020) != 0)) { + output.writeMessage(6, getStmtExecute()); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(1, type_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, getFind()); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(3, getInsert()); + } + if (((bitField0_ & 0x00000008) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(4, getUpdate()); + } + if (((bitField0_ & 0x00000010) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(5, getDelete()); + } + if (((bitField0_ & 0x00000020) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(6, getStmtExecute()); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage other = (com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage) obj; + + if (hasType() != other.hasType()) return false; + if (hasType()) { + if (type_ != other.type_) return false; + } + if (hasFind() != other.hasFind()) return false; + if (hasFind()) { + if (!getFind() + .equals(other.getFind())) return false; + } + if (hasInsert() != other.hasInsert()) return false; + if (hasInsert()) { + if (!getInsert() + .equals(other.getInsert())) return false; + } + if (hasUpdate() != other.hasUpdate()) return false; + if (hasUpdate()) { + if (!getUpdate() + .equals(other.getUpdate())) return false; + } + if (hasDelete() != other.hasDelete()) return false; + if (hasDelete()) { + if (!getDelete() + .equals(other.getDelete())) return false; + } + if (hasStmtExecute() != other.hasStmtExecute()) return false; + if (hasStmtExecute()) { + if (!getStmtExecute() + .equals(other.getStmtExecute())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasType()) { + hash = (37 * hash) + TYPE_FIELD_NUMBER; + hash = (53 * hash) + type_; + } + if (hasFind()) { + hash = (37 * hash) + FIND_FIELD_NUMBER; + hash = (53 * hash) + getFind().hashCode(); + } + if (hasInsert()) { + hash = (37 * hash) + INSERT_FIELD_NUMBER; + hash = (53 * hash) + getInsert().hashCode(); + } + if (hasUpdate()) { + hash = (37 * hash) + UPDATE_FIELD_NUMBER; + hash = (53 * hash) + getUpdate().hashCode(); + } + if (hasDelete()) { + hash = (37 * hash) + DELETE_FIELD_NUMBER; + hash = (53 * hash) + getDelete().hashCode(); + } + if (hasStmtExecute()) { + hash = (37 * hash) + STMT_EXECUTE_FIELD_NUMBER; + hash = (53 * hash) + getStmtExecute().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * Protobuf type {@code Mysqlx.Prepare.Prepare.OneOfMessage} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Prepare.Prepare.OneOfMessage) + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessageOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.internal_static_Mysqlx_Prepare_Prepare_OneOfMessage_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.internal_static_Mysqlx_Prepare_Prepare_OneOfMessage_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.class, com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getFindFieldBuilder(); + getInsertFieldBuilder(); + getUpdateFieldBuilder(); + getDeleteFieldBuilder(); + getStmtExecuteFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + type_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + if (findBuilder_ == null) { + find_ = null; + } else { + findBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + if (insertBuilder_ == null) { + insert_ = null; + } else { + insertBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + if (updateBuilder_ == null) { + update_ = null; + } else { + updateBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + if (deleteBuilder_ == null) { + delete_ = null; + } else { + deleteBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000010); + if (stmtExecuteBuilder_ == null) { + stmtExecute_ = null; + } else { + stmtExecuteBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000020); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.internal_static_Mysqlx_Prepare_Prepare_OneOfMessage_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage build() { + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage buildPartial() { + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage result = new com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.type_ = type_; + if (((from_bitField0_ & 0x00000002) != 0)) { + if (findBuilder_ == null) { + result.find_ = find_; + } else { + result.find_ = findBuilder_.build(); + } + to_bitField0_ |= 0x00000002; + } + if (((from_bitField0_ & 0x00000004) != 0)) { + if (insertBuilder_ == null) { + result.insert_ = insert_; + } else { + result.insert_ = insertBuilder_.build(); + } + to_bitField0_ |= 0x00000004; + } + if (((from_bitField0_ & 0x00000008) != 0)) { + if (updateBuilder_ == null) { + result.update_ = update_; + } else { + result.update_ = updateBuilder_.build(); + } + to_bitField0_ |= 0x00000008; + } + if (((from_bitField0_ & 0x00000010) != 0)) { + if (deleteBuilder_ == null) { + result.delete_ = delete_; + } else { + result.delete_ = deleteBuilder_.build(); + } + to_bitField0_ |= 0x00000010; + } + if (((from_bitField0_ & 0x00000020) != 0)) { + if (stmtExecuteBuilder_ == null) { + result.stmtExecute_ = stmtExecute_; + } else { + result.stmtExecute_ = stmtExecuteBuilder_.build(); + } + to_bitField0_ |= 0x00000020; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage other) { + if (other == com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.getDefaultInstance()) return this; + if (other.hasType()) { + setType(other.getType()); + } + if (other.hasFind()) { + mergeFind(other.getFind()); + } + if (other.hasInsert()) { + mergeInsert(other.getInsert()); + } + if (other.hasUpdate()) { + mergeUpdate(other.getUpdate()); + } + if (other.hasDelete()) { + mergeDelete(other.getDelete()); + } + if (other.hasStmtExecute()) { + mergeStmtExecute(other.getStmtExecute()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasType()) { + return false; + } + if (hasFind()) { + if (!getFind().isInitialized()) { + return false; + } + } + if (hasInsert()) { + if (!getInsert().isInitialized()) { + return false; + } + } + if (hasUpdate()) { + if (!getUpdate().isInitialized()) { + return false; + } + } + if (hasDelete()) { + if (!getDelete().isInitialized()) { + return false; + } + } + if (hasStmtExecute()) { + if (!getStmtExecute().isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int type_ = 0; + /** + * required .Mysqlx.Prepare.Prepare.OneOfMessage.Type type = 1; + * @return Whether the type field is set. + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * required .Mysqlx.Prepare.Prepare.OneOfMessage.Type type = 1; + * @return The type. + */ + public com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.Type getType() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.Type result = com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.Type.valueOf(type_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.Type.FIND : result; + } + /** + * required .Mysqlx.Prepare.Prepare.OneOfMessage.Type type = 1; + * @param value The type to set. + * @return This builder for chaining. + */ + public Builder setType(com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.Type value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + type_ = value.getNumber(); + onChanged(); + return this; + } + /** + * required .Mysqlx.Prepare.Prepare.OneOfMessage.Type type = 1; + * @return This builder for chaining. + */ + public Builder clearType() { + bitField0_ = (bitField0_ & ~0x00000001); + type_ = 0; + onChanged(); + return this; + } + + private com.mysql.cj.x.protobuf.MysqlxCrud.Find find_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Find, com.mysql.cj.x.protobuf.MysqlxCrud.Find.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.FindOrBuilder> findBuilder_; + /** + * optional .Mysqlx.Crud.Find find = 2; + * @return Whether the find field is set. + */ + public boolean hasFind() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * optional .Mysqlx.Crud.Find find = 2; + * @return The find. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Find getFind() { + if (findBuilder_ == null) { + return find_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Find.getDefaultInstance() : find_; + } else { + return findBuilder_.getMessage(); + } + } + /** + * optional .Mysqlx.Crud.Find find = 2; + */ + public Builder setFind(com.mysql.cj.x.protobuf.MysqlxCrud.Find value) { + if (findBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + find_ = value; + onChanged(); + } else { + findBuilder_.setMessage(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .Mysqlx.Crud.Find find = 2; + */ + public Builder setFind( + com.mysql.cj.x.protobuf.MysqlxCrud.Find.Builder builderForValue) { + if (findBuilder_ == null) { + find_ = builderForValue.build(); + onChanged(); + } else { + findBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .Mysqlx.Crud.Find find = 2; + */ + public Builder mergeFind(com.mysql.cj.x.protobuf.MysqlxCrud.Find value) { + if (findBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0) && + find_ != null && + find_ != com.mysql.cj.x.protobuf.MysqlxCrud.Find.getDefaultInstance()) { + find_ = + com.mysql.cj.x.protobuf.MysqlxCrud.Find.newBuilder(find_).mergeFrom(value).buildPartial(); + } else { + find_ = value; + } + onChanged(); + } else { + findBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * optional .Mysqlx.Crud.Find find = 2; + */ + public Builder clearFind() { + if (findBuilder_ == null) { + find_ = null; + onChanged(); + } else { + findBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + /** + * optional .Mysqlx.Crud.Find find = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Find.Builder getFindBuilder() { + bitField0_ |= 0x00000002; + onChanged(); + return getFindFieldBuilder().getBuilder(); + } + /** + * optional .Mysqlx.Crud.Find find = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.FindOrBuilder getFindOrBuilder() { + if (findBuilder_ != null) { + return findBuilder_.getMessageOrBuilder(); + } else { + return find_ == null ? + com.mysql.cj.x.protobuf.MysqlxCrud.Find.getDefaultInstance() : find_; + } + } + /** + * optional .Mysqlx.Crud.Find find = 2; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Find, com.mysql.cj.x.protobuf.MysqlxCrud.Find.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.FindOrBuilder> + getFindFieldBuilder() { + if (findBuilder_ == null) { + findBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Find, com.mysql.cj.x.protobuf.MysqlxCrud.Find.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.FindOrBuilder>( + getFind(), + getParentForChildren(), + isClean()); + find_ = null; + } + return findBuilder_; + } + + private com.mysql.cj.x.protobuf.MysqlxCrud.Insert insert_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Insert, com.mysql.cj.x.protobuf.MysqlxCrud.Insert.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.InsertOrBuilder> insertBuilder_; + /** + * optional .Mysqlx.Crud.Insert insert = 3; + * @return Whether the insert field is set. + */ + public boolean hasInsert() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * optional .Mysqlx.Crud.Insert insert = 3; + * @return The insert. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Insert getInsert() { + if (insertBuilder_ == null) { + return insert_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Insert.getDefaultInstance() : insert_; + } else { + return insertBuilder_.getMessage(); + } + } + /** + * optional .Mysqlx.Crud.Insert insert = 3; + */ + public Builder setInsert(com.mysql.cj.x.protobuf.MysqlxCrud.Insert value) { + if (insertBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + insert_ = value; + onChanged(); + } else { + insertBuilder_.setMessage(value); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .Mysqlx.Crud.Insert insert = 3; + */ + public Builder setInsert( + com.mysql.cj.x.protobuf.MysqlxCrud.Insert.Builder builderForValue) { + if (insertBuilder_ == null) { + insert_ = builderForValue.build(); + onChanged(); + } else { + insertBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .Mysqlx.Crud.Insert insert = 3; + */ + public Builder mergeInsert(com.mysql.cj.x.protobuf.MysqlxCrud.Insert value) { + if (insertBuilder_ == null) { + if (((bitField0_ & 0x00000004) != 0) && + insert_ != null && + insert_ != com.mysql.cj.x.protobuf.MysqlxCrud.Insert.getDefaultInstance()) { + insert_ = + com.mysql.cj.x.protobuf.MysqlxCrud.Insert.newBuilder(insert_).mergeFrom(value).buildPartial(); + } else { + insert_ = value; + } + onChanged(); + } else { + insertBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000004; + return this; + } + /** + * optional .Mysqlx.Crud.Insert insert = 3; + */ + public Builder clearInsert() { + if (insertBuilder_ == null) { + insert_ = null; + onChanged(); + } else { + insertBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + /** + * optional .Mysqlx.Crud.Insert insert = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Insert.Builder getInsertBuilder() { + bitField0_ |= 0x00000004; + onChanged(); + return getInsertFieldBuilder().getBuilder(); + } + /** + * optional .Mysqlx.Crud.Insert insert = 3; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.InsertOrBuilder getInsertOrBuilder() { + if (insertBuilder_ != null) { + return insertBuilder_.getMessageOrBuilder(); + } else { + return insert_ == null ? + com.mysql.cj.x.protobuf.MysqlxCrud.Insert.getDefaultInstance() : insert_; + } + } + /** + * optional .Mysqlx.Crud.Insert insert = 3; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Insert, com.mysql.cj.x.protobuf.MysqlxCrud.Insert.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.InsertOrBuilder> + getInsertFieldBuilder() { + if (insertBuilder_ == null) { + insertBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Insert, com.mysql.cj.x.protobuf.MysqlxCrud.Insert.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.InsertOrBuilder>( + getInsert(), + getParentForChildren(), + isClean()); + insert_ = null; + } + return insertBuilder_; + } + + private com.mysql.cj.x.protobuf.MysqlxCrud.Update update_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Update, com.mysql.cj.x.protobuf.MysqlxCrud.Update.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOrBuilder> updateBuilder_; + /** + * optional .Mysqlx.Crud.Update update = 4; + * @return Whether the update field is set. + */ + public boolean hasUpdate() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * optional .Mysqlx.Crud.Update update = 4; + * @return The update. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Update getUpdate() { + if (updateBuilder_ == null) { + return update_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Update.getDefaultInstance() : update_; + } else { + return updateBuilder_.getMessage(); + } + } + /** + * optional .Mysqlx.Crud.Update update = 4; + */ + public Builder setUpdate(com.mysql.cj.x.protobuf.MysqlxCrud.Update value) { + if (updateBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + update_ = value; + onChanged(); + } else { + updateBuilder_.setMessage(value); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .Mysqlx.Crud.Update update = 4; + */ + public Builder setUpdate( + com.mysql.cj.x.protobuf.MysqlxCrud.Update.Builder builderForValue) { + if (updateBuilder_ == null) { + update_ = builderForValue.build(); + onChanged(); + } else { + updateBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .Mysqlx.Crud.Update update = 4; + */ + public Builder mergeUpdate(com.mysql.cj.x.protobuf.MysqlxCrud.Update value) { + if (updateBuilder_ == null) { + if (((bitField0_ & 0x00000008) != 0) && + update_ != null && + update_ != com.mysql.cj.x.protobuf.MysqlxCrud.Update.getDefaultInstance()) { + update_ = + com.mysql.cj.x.protobuf.MysqlxCrud.Update.newBuilder(update_).mergeFrom(value).buildPartial(); + } else { + update_ = value; + } + onChanged(); + } else { + updateBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000008; + return this; + } + /** + * optional .Mysqlx.Crud.Update update = 4; + */ + public Builder clearUpdate() { + if (updateBuilder_ == null) { + update_ = null; + onChanged(); + } else { + updateBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + /** + * optional .Mysqlx.Crud.Update update = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Update.Builder getUpdateBuilder() { + bitField0_ |= 0x00000008; + onChanged(); + return getUpdateFieldBuilder().getBuilder(); + } + /** + * optional .Mysqlx.Crud.Update update = 4; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOrBuilder getUpdateOrBuilder() { + if (updateBuilder_ != null) { + return updateBuilder_.getMessageOrBuilder(); + } else { + return update_ == null ? + com.mysql.cj.x.protobuf.MysqlxCrud.Update.getDefaultInstance() : update_; + } + } + /** + * optional .Mysqlx.Crud.Update update = 4; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Update, com.mysql.cj.x.protobuf.MysqlxCrud.Update.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOrBuilder> + getUpdateFieldBuilder() { + if (updateBuilder_ == null) { + updateBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Update, com.mysql.cj.x.protobuf.MysqlxCrud.Update.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.UpdateOrBuilder>( + getUpdate(), + getParentForChildren(), + isClean()); + update_ = null; + } + return updateBuilder_; + } + + private com.mysql.cj.x.protobuf.MysqlxCrud.Delete delete_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Delete, com.mysql.cj.x.protobuf.MysqlxCrud.Delete.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.DeleteOrBuilder> deleteBuilder_; + /** + * optional .Mysqlx.Crud.Delete delete = 5; + * @return Whether the delete field is set. + */ + public boolean hasDelete() { + return ((bitField0_ & 0x00000010) != 0); + } + /** + * optional .Mysqlx.Crud.Delete delete = 5; + * @return The delete. + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Delete getDelete() { + if (deleteBuilder_ == null) { + return delete_ == null ? com.mysql.cj.x.protobuf.MysqlxCrud.Delete.getDefaultInstance() : delete_; + } else { + return deleteBuilder_.getMessage(); + } + } + /** + * optional .Mysqlx.Crud.Delete delete = 5; + */ + public Builder setDelete(com.mysql.cj.x.protobuf.MysqlxCrud.Delete value) { + if (deleteBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + delete_ = value; + onChanged(); + } else { + deleteBuilder_.setMessage(value); + } + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .Mysqlx.Crud.Delete delete = 5; + */ + public Builder setDelete( + com.mysql.cj.x.protobuf.MysqlxCrud.Delete.Builder builderForValue) { + if (deleteBuilder_ == null) { + delete_ = builderForValue.build(); + onChanged(); + } else { + deleteBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .Mysqlx.Crud.Delete delete = 5; + */ + public Builder mergeDelete(com.mysql.cj.x.protobuf.MysqlxCrud.Delete value) { + if (deleteBuilder_ == null) { + if (((bitField0_ & 0x00000010) != 0) && + delete_ != null && + delete_ != com.mysql.cj.x.protobuf.MysqlxCrud.Delete.getDefaultInstance()) { + delete_ = + com.mysql.cj.x.protobuf.MysqlxCrud.Delete.newBuilder(delete_).mergeFrom(value).buildPartial(); + } else { + delete_ = value; + } + onChanged(); + } else { + deleteBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000010; + return this; + } + /** + * optional .Mysqlx.Crud.Delete delete = 5; + */ + public Builder clearDelete() { + if (deleteBuilder_ == null) { + delete_ = null; + onChanged(); + } else { + deleteBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000010); + return this; + } + /** + * optional .Mysqlx.Crud.Delete delete = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.Delete.Builder getDeleteBuilder() { + bitField0_ |= 0x00000010; + onChanged(); + return getDeleteFieldBuilder().getBuilder(); + } + /** + * optional .Mysqlx.Crud.Delete delete = 5; + */ + public com.mysql.cj.x.protobuf.MysqlxCrud.DeleteOrBuilder getDeleteOrBuilder() { + if (deleteBuilder_ != null) { + return deleteBuilder_.getMessageOrBuilder(); + } else { + return delete_ == null ? + com.mysql.cj.x.protobuf.MysqlxCrud.Delete.getDefaultInstance() : delete_; + } + } + /** + * optional .Mysqlx.Crud.Delete delete = 5; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Delete, com.mysql.cj.x.protobuf.MysqlxCrud.Delete.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.DeleteOrBuilder> + getDeleteFieldBuilder() { + if (deleteBuilder_ == null) { + deleteBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxCrud.Delete, com.mysql.cj.x.protobuf.MysqlxCrud.Delete.Builder, com.mysql.cj.x.protobuf.MysqlxCrud.DeleteOrBuilder>( + getDelete(), + getParentForChildren(), + isClean()); + delete_ = null; + } + return deleteBuilder_; + } + + private com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute stmtExecute_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute, com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute.Builder, com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOrBuilder> stmtExecuteBuilder_; + /** + * optional .Mysqlx.Sql.StmtExecute stmt_execute = 6; + * @return Whether the stmtExecute field is set. + */ + public boolean hasStmtExecute() { + return ((bitField0_ & 0x00000020) != 0); + } + /** + * optional .Mysqlx.Sql.StmtExecute stmt_execute = 6; + * @return The stmtExecute. + */ + public com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute getStmtExecute() { + if (stmtExecuteBuilder_ == null) { + return stmtExecute_ == null ? com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute.getDefaultInstance() : stmtExecute_; + } else { + return stmtExecuteBuilder_.getMessage(); + } + } + /** + * optional .Mysqlx.Sql.StmtExecute stmt_execute = 6; + */ + public Builder setStmtExecute(com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute value) { + if (stmtExecuteBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + stmtExecute_ = value; + onChanged(); + } else { + stmtExecuteBuilder_.setMessage(value); + } + bitField0_ |= 0x00000020; + return this; + } + /** + * optional .Mysqlx.Sql.StmtExecute stmt_execute = 6; + */ + public Builder setStmtExecute( + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute.Builder builderForValue) { + if (stmtExecuteBuilder_ == null) { + stmtExecute_ = builderForValue.build(); + onChanged(); + } else { + stmtExecuteBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000020; + return this; + } + /** + * optional .Mysqlx.Sql.StmtExecute stmt_execute = 6; + */ + public Builder mergeStmtExecute(com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute value) { + if (stmtExecuteBuilder_ == null) { + if (((bitField0_ & 0x00000020) != 0) && + stmtExecute_ != null && + stmtExecute_ != com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute.getDefaultInstance()) { + stmtExecute_ = + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute.newBuilder(stmtExecute_).mergeFrom(value).buildPartial(); + } else { + stmtExecute_ = value; + } + onChanged(); + } else { + stmtExecuteBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000020; + return this; + } + /** + * optional .Mysqlx.Sql.StmtExecute stmt_execute = 6; + */ + public Builder clearStmtExecute() { + if (stmtExecuteBuilder_ == null) { + stmtExecute_ = null; + onChanged(); + } else { + stmtExecuteBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000020); + return this; + } + /** + * optional .Mysqlx.Sql.StmtExecute stmt_execute = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute.Builder getStmtExecuteBuilder() { + bitField0_ |= 0x00000020; + onChanged(); + return getStmtExecuteFieldBuilder().getBuilder(); + } + /** + * optional .Mysqlx.Sql.StmtExecute stmt_execute = 6; + */ + public com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOrBuilder getStmtExecuteOrBuilder() { + if (stmtExecuteBuilder_ != null) { + return stmtExecuteBuilder_.getMessageOrBuilder(); + } else { + return stmtExecute_ == null ? + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute.getDefaultInstance() : stmtExecute_; + } + } + /** + * optional .Mysqlx.Sql.StmtExecute stmt_execute = 6; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute, com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute.Builder, com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOrBuilder> + getStmtExecuteFieldBuilder() { + if (stmtExecuteBuilder_ == null) { + stmtExecuteBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute, com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute.Builder, com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOrBuilder>( + getStmtExecute(), + getParentForChildren(), + isClean()); + stmtExecute_ = null; + } + return stmtExecuteBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Prepare.Prepare.OneOfMessage) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Prepare.Prepare.OneOfMessage) + private static final com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage(); + } + + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public OneOfMessage parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new OneOfMessage(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private int bitField0_; + public static final int STMT_ID_FIELD_NUMBER = 1; + private int stmtId_; + /** + * 
+     ** client side assigned statement id, which is going to identify
+     *the result of preparation 
+     *
+ * + * required uint32 stmt_id = 1; + * @return Whether the stmtId field is set. + */ + public boolean hasStmtId() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** client side assigned statement id, which is going to identify
+     *the result of preparation 
+     *
+ * + * required uint32 stmt_id = 1; + * @return The stmtId. + */ + public int getStmtId() { + return stmtId_; + } + + public static final int STMT_FIELD_NUMBER = 2; + private com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage stmt_; + /** + * 
+     ** defines one of following messages to be prepared:
+     *Crud::Find, Crud::Insert, Crud::Delete, Crud::Upsert, Sql::StmtExecute 
+     *
+ * + * required .Mysqlx.Prepare.Prepare.OneOfMessage stmt = 2; + * @return Whether the stmt field is set. + */ + public boolean hasStmt() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** defines one of following messages to be prepared:
+     *Crud::Find, Crud::Insert, Crud::Delete, Crud::Upsert, Sql::StmtExecute 
+     *
+ * + * required .Mysqlx.Prepare.Prepare.OneOfMessage stmt = 2; + * @return The stmt. + */ + public com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage getStmt() { + return stmt_ == null ? com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.getDefaultInstance() : stmt_; + } + /** + * 
+     ** defines one of following messages to be prepared:
+     *Crud::Find, Crud::Insert, Crud::Delete, Crud::Upsert, Sql::StmtExecute 
+     *
+ * + * required .Mysqlx.Prepare.Prepare.OneOfMessage stmt = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessageOrBuilder getStmtOrBuilder() { + return stmt_ == null ? com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.getDefaultInstance() : stmt_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasStmtId()) { + memoizedIsInitialized = 0; + return false; + } + if (!hasStmt()) { + memoizedIsInitialized = 0; + return false; + } + if (!getStmt().isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeUInt32(1, stmtId_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeMessage(2, getStmt()); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(1, stmtId_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, getStmt()); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare other = (com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare) obj; + + if (hasStmtId() != other.hasStmtId()) return false; + if (hasStmtId()) { + if (getStmtId() + != other.getStmtId()) return false; + } + if (hasStmt() != other.hasStmt()) return false; + if (hasStmt()) { + if (!getStmt() + .equals(other.getStmt())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasStmtId()) { + hash = (37 * hash) + STMT_ID_FIELD_NUMBER; + hash = (53 * hash) + getStmtId(); + } + if (hasStmt()) { + hash = (37 * hash) + STMT_FIELD_NUMBER; + hash = (53 * hash) + getStmt().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Prepare a new statement
+     *@startuml
+     *client -> server: Prepare
+     *alt Success
+     *client <- server: Ok
+     *else Failure
+     *client <- server: Error
+     *end
+     *@enduml
+     *@returns @ref Mysqlx::Ok or @ref Mysqlx::Error
+     *
+ * + * Protobuf type {@code Mysqlx.Prepare.Prepare} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Prepare.Prepare) + com.mysql.cj.x.protobuf.MysqlxPrepare.PrepareOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.internal_static_Mysqlx_Prepare_Prepare_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.internal_static_Mysqlx_Prepare_Prepare_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.class, com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getStmtFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + stmtId_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + if (stmtBuilder_ == null) { + stmt_ = null; + } else { + stmtBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.internal_static_Mysqlx_Prepare_Prepare_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare build() { + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare buildPartial() { + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare result = new com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.stmtId_ = stmtId_; + to_bitField0_ |= 0x00000001; + } + if (((from_bitField0_ & 0x00000002) != 0)) { + if (stmtBuilder_ == null) { + result.stmt_ = stmt_; + } else { + result.stmt_ = stmtBuilder_.build(); + } + to_bitField0_ |= 0x00000002; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare other) { + if (other == com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.getDefaultInstance()) return this; + if (other.hasStmtId()) { + setStmtId(other.getStmtId()); + } + if (other.hasStmt()) { + mergeStmt(other.getStmt()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasStmtId()) { + return false; + } + if (!hasStmt()) { + return false; + } + if (!getStmt().isInitialized()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int stmtId_ ; + /** + * 
+       ** client side assigned statement id, which is going to identify
+       *the result of preparation 
+       *
+ * + * required uint32 stmt_id = 1; + * @return Whether the stmtId field is set. + */ + public boolean hasStmtId() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** client side assigned statement id, which is going to identify
+       *the result of preparation 
+       *
+ * + * required uint32 stmt_id = 1; + * @return The stmtId. + */ + public int getStmtId() { + return stmtId_; + } + /** + * 
+       ** client side assigned statement id, which is going to identify
+       *the result of preparation 
+       *
+ * + * required uint32 stmt_id = 1; + * @param value The stmtId to set. + * @return This builder for chaining. + */ + public Builder setStmtId(int value) { + bitField0_ |= 0x00000001; + stmtId_ = value; + onChanged(); + return this; + } + /** + * 
+       ** client side assigned statement id, which is going to identify
+       *the result of preparation 
+       *
+ * + * required uint32 stmt_id = 1; + * @return This builder for chaining. + */ + public Builder clearStmtId() { + bitField0_ = (bitField0_ & ~0x00000001); + stmtId_ = 0; + onChanged(); + return this; + } + + private com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage stmt_; + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage, com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.Builder, com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessageOrBuilder> stmtBuilder_; + /** + * 
+       ** defines one of following messages to be prepared:
+       *Crud::Find, Crud::Insert, Crud::Delete, Crud::Upsert, Sql::StmtExecute 
+       *
+ * + * required .Mysqlx.Prepare.Prepare.OneOfMessage stmt = 2; + * @return Whether the stmt field is set. + */ + public boolean hasStmt() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** defines one of following messages to be prepared:
+       *Crud::Find, Crud::Insert, Crud::Delete, Crud::Upsert, Sql::StmtExecute 
+       *
+ * + * required .Mysqlx.Prepare.Prepare.OneOfMessage stmt = 2; + * @return The stmt. + */ + public com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage getStmt() { + if (stmtBuilder_ == null) { + return stmt_ == null ? com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.getDefaultInstance() : stmt_; + } else { + return stmtBuilder_.getMessage(); + } + } + /** + * 
+       ** defines one of following messages to be prepared:
+       *Crud::Find, Crud::Insert, Crud::Delete, Crud::Upsert, Sql::StmtExecute 
+       *
+ * + * required .Mysqlx.Prepare.Prepare.OneOfMessage stmt = 2; + */ + public Builder setStmt(com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage value) { + if (stmtBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + stmt_ = value; + onChanged(); + } else { + stmtBuilder_.setMessage(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * 
+       ** defines one of following messages to be prepared:
+       *Crud::Find, Crud::Insert, Crud::Delete, Crud::Upsert, Sql::StmtExecute 
+       *
+ * + * required .Mysqlx.Prepare.Prepare.OneOfMessage stmt = 2; + */ + public Builder setStmt( + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.Builder builderForValue) { + if (stmtBuilder_ == null) { + stmt_ = builderForValue.build(); + onChanged(); + } else { + stmtBuilder_.setMessage(builderForValue.build()); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * 
+       ** defines one of following messages to be prepared:
+       *Crud::Find, Crud::Insert, Crud::Delete, Crud::Upsert, Sql::StmtExecute 
+       *
+ * + * required .Mysqlx.Prepare.Prepare.OneOfMessage stmt = 2; + */ + public Builder mergeStmt(com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage value) { + if (stmtBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0) && + stmt_ != null && + stmt_ != com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.getDefaultInstance()) { + stmt_ = + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.newBuilder(stmt_).mergeFrom(value).buildPartial(); + } else { + stmt_ = value; + } + onChanged(); + } else { + stmtBuilder_.mergeFrom(value); + } + bitField0_ |= 0x00000002; + return this; + } + /** + * 
+       ** defines one of following messages to be prepared:
+       *Crud::Find, Crud::Insert, Crud::Delete, Crud::Upsert, Sql::StmtExecute 
+       *
+ * + * required .Mysqlx.Prepare.Prepare.OneOfMessage stmt = 2; + */ + public Builder clearStmt() { + if (stmtBuilder_ == null) { + stmt_ = null; + onChanged(); + } else { + stmtBuilder_.clear(); + } + bitField0_ = (bitField0_ & ~0x00000002); + return this; + } + /** + * 
+       ** defines one of following messages to be prepared:
+       *Crud::Find, Crud::Insert, Crud::Delete, Crud::Upsert, Sql::StmtExecute 
+       *
+ * + * required .Mysqlx.Prepare.Prepare.OneOfMessage stmt = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.Builder getStmtBuilder() { + bitField0_ |= 0x00000002; + onChanged(); + return getStmtFieldBuilder().getBuilder(); + } + /** + * 
+       ** defines one of following messages to be prepared:
+       *Crud::Find, Crud::Insert, Crud::Delete, Crud::Upsert, Sql::StmtExecute 
+       *
+ * + * required .Mysqlx.Prepare.Prepare.OneOfMessage stmt = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessageOrBuilder getStmtOrBuilder() { + if (stmtBuilder_ != null) { + return stmtBuilder_.getMessageOrBuilder(); + } else { + return stmt_ == null ? + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.getDefaultInstance() : stmt_; + } + } + /** + * 
+       ** defines one of following messages to be prepared:
+       *Crud::Find, Crud::Insert, Crud::Delete, Crud::Upsert, Sql::StmtExecute 
+       *
+ * + * required .Mysqlx.Prepare.Prepare.OneOfMessage stmt = 2; + */ + private com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage, com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.Builder, com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessageOrBuilder> + getStmtFieldBuilder() { + if (stmtBuilder_ == null) { + stmtBuilder_ = new com.google.protobuf.SingleFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage, com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessage.Builder, com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare.OneOfMessageOrBuilder>( + getStmt(), + getParentForChildren(), + isClean()); + stmt_ = null; + } + return stmtBuilder_; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Prepare.Prepare) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Prepare.Prepare) + private static final com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare(); + } + + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Prepare parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Prepare(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxPrepare.Prepare getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ExecuteOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Prepare.Execute) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** client side assigned statement id, must be already prepared 
+     *
+ * + * required uint32 stmt_id = 1; + * @return Whether the stmtId field is set. + */ + boolean hasStmtId(); + /** + * 
+     ** client side assigned statement id, must be already prepared 
+     *
+ * + * required uint32 stmt_id = 1; + * @return The stmtId. + */ + int getStmtId(); + + /** + * 
+     ** Arguments to bind to the prepared statement 
+     *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + java.util.List + getArgsList(); + /** + * 
+     ** Arguments to bind to the prepared statement 
+     *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any getArgs(int index); + /** + * 
+     ** Arguments to bind to the prepared statement 
+     *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + int getArgsCount(); + /** + * 
+     ** Arguments to bind to the prepared statement 
+     *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + java.util.List + getArgsOrBuilderList(); + /** + * 
+     ** Arguments to bind to the prepared statement 
+     *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder getArgsOrBuilder( + int index); + + /** + * 
+     ** send only type information for
+     *@ref Mysqlx::Resultset::ColumnMetaData, skipping names and others 
+     *
+ * + * optional bool compact_metadata = 3 [default = false]; + * @return Whether the compactMetadata field is set. + */ + boolean hasCompactMetadata(); + /** + * 
+     ** send only type information for
+     *@ref Mysqlx::Resultset::ColumnMetaData, skipping names and others 
+     *
+ * + * optional bool compact_metadata = 3 [default = false]; + * @return The compactMetadata. + */ + boolean getCompactMetadata(); + } + /** + * 
+   **
+   *Execute already prepared statement
+   *@startuml
+   *client -> server: Execute
+   *alt Success
+   *... Resultsets...
+   *client <- server: StmtExecuteOk
+   *else Failure
+   *client <- server: Error
+   *end
+   *@enduml
+   *@returns @ref Mysqlx::Ok
+   *
+ * + * Protobuf type {@code Mysqlx.Prepare.Execute} + */ + public static final class Execute extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Prepare.Execute) + ExecuteOrBuilder { + private static final long serialVersionUID = 0L; + // Use Execute.newBuilder() to construct. + private Execute(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Execute() { + args_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Execute(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Execute( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + bitField0_ |= 0x00000001; + stmtId_ = input.readUInt32(); + break; + } + case 18: { + if (!((mutable_bitField0_ & 0x00000002) != 0)) { + args_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000002; + } + args_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.PARSER, extensionRegistry)); + break; + } + case 24: { + bitField0_ |= 0x00000002; + compactMetadata_ = input.readBool(); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000002) != 0)) { + args_ = java.util.Collections.unmodifiableList(args_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.internal_static_Mysqlx_Prepare_Execute_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.internal_static_Mysqlx_Prepare_Execute_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxPrepare.Execute.class, com.mysql.cj.x.protobuf.MysqlxPrepare.Execute.Builder.class); + } + + private int bitField0_; + public static final int STMT_ID_FIELD_NUMBER = 1; + private int stmtId_; + /** + * 
+     ** client side assigned statement id, must be already prepared 
+     *
+ * + * required uint32 stmt_id = 1; + * @return Whether the stmtId field is set. + */ + public boolean hasStmtId() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** client side assigned statement id, must be already prepared 
+     *
+ * + * required uint32 stmt_id = 1; + * @return The stmtId. + */ + public int getStmtId() { + return stmtId_; + } + + public static final int ARGS_FIELD_NUMBER = 2; + private java.util.List args_; + /** + * 
+     ** Arguments to bind to the prepared statement 
+     *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public java.util.List getArgsList() { + return args_; + } + /** + * 
+     ** Arguments to bind to the prepared statement 
+     *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public java.util.List + getArgsOrBuilderList() { + return args_; + } + /** + * 
+     ** Arguments to bind to the prepared statement 
+     *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public int getArgsCount() { + return args_.size(); + } + /** + * 
+     ** Arguments to bind to the prepared statement 
+     *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any getArgs(int index) { + return args_.get(index); + } + /** + * 
+     ** Arguments to bind to the prepared statement 
+     *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder getArgsOrBuilder( + int index) { + return args_.get(index); + } + + public static final int COMPACT_METADATA_FIELD_NUMBER = 3; + private boolean compactMetadata_; + /** + * 
+     ** send only type information for
+     *@ref Mysqlx::Resultset::ColumnMetaData, skipping names and others 
+     *
+ * + * optional bool compact_metadata = 3 [default = false]; + * @return Whether the compactMetadata field is set. + */ + public boolean hasCompactMetadata() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** send only type information for
+     *@ref Mysqlx::Resultset::ColumnMetaData, skipping names and others 
+     *
+ * + * optional bool compact_metadata = 3 [default = false]; + * @return The compactMetadata. + */ + public boolean getCompactMetadata() { + return compactMetadata_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasStmtId()) { + memoizedIsInitialized = 0; + return false; + } + for (int i = 0; i < getArgsCount(); i++) { + if (!getArgs(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeUInt32(1, stmtId_); + } + for (int i = 0; i < args_.size(); i++) { + output.writeMessage(2, args_.get(i)); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeBool(3, compactMetadata_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(1, stmtId_); + } + for (int i = 0; i < args_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, args_.get(i)); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(3, compactMetadata_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxPrepare.Execute)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxPrepare.Execute other = (com.mysql.cj.x.protobuf.MysqlxPrepare.Execute) obj; + + if (hasStmtId() != other.hasStmtId()) return false; + if (hasStmtId()) { + if (getStmtId() + != other.getStmtId()) return false; + } + if (!getArgsList() + .equals(other.getArgsList())) return false; + if (hasCompactMetadata() != other.hasCompactMetadata()) return false; + if (hasCompactMetadata()) { + if (getCompactMetadata() + != other.getCompactMetadata()) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasStmtId()) { + hash = (37 * hash) + STMT_ID_FIELD_NUMBER; + hash = (53 * hash) + getStmtId(); + } + if (getArgsCount() > 0) { + hash = (37 * hash) + ARGS_FIELD_NUMBER; + hash = (53 * hash) + getArgsList().hashCode(); + } + if (hasCompactMetadata()) { + hash = (37 * hash) + COMPACT_METADATA_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getCompactMetadata()); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Execute parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Execute parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Execute parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Execute parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Execute parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Execute parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Execute parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Execute parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Execute parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Execute parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Execute parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Execute parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxPrepare.Execute prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Execute already prepared statement
+     *@startuml
+     *client -> server: Execute
+     *alt Success
+     *... Resultsets...
+     *client <- server: StmtExecuteOk
+     *else Failure
+     *client <- server: Error
+     *end
+     *@enduml
+     *@returns @ref Mysqlx::Ok
+     *
+ * + * Protobuf type {@code Mysqlx.Prepare.Execute} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Prepare.Execute) + com.mysql.cj.x.protobuf.MysqlxPrepare.ExecuteOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.internal_static_Mysqlx_Prepare_Execute_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.internal_static_Mysqlx_Prepare_Execute_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxPrepare.Execute.class, com.mysql.cj.x.protobuf.MysqlxPrepare.Execute.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxPrepare.Execute.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getArgsFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + stmtId_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + if (argsBuilder_ == null) { + args_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + } else { + argsBuilder_.clear(); + } + compactMetadata_ = false; + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.internal_static_Mysqlx_Prepare_Execute_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxPrepare.Execute getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.Execute.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxPrepare.Execute build() { + com.mysql.cj.x.protobuf.MysqlxPrepare.Execute result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxPrepare.Execute buildPartial() { + com.mysql.cj.x.protobuf.MysqlxPrepare.Execute result = new com.mysql.cj.x.protobuf.MysqlxPrepare.Execute(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.stmtId_ = stmtId_; + to_bitField0_ |= 0x00000001; + } + if (argsBuilder_ == null) { + if (((bitField0_ & 0x00000002) != 0)) { + args_ = java.util.Collections.unmodifiableList(args_); + bitField0_ = (bitField0_ & ~0x00000002); + } + result.args_ = args_; + } else { + result.args_ = argsBuilder_.build(); + } + if (((from_bitField0_ & 0x00000004) != 0)) { + result.compactMetadata_ = compactMetadata_; + to_bitField0_ |= 0x00000002; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxPrepare.Execute) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxPrepare.Execute)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxPrepare.Execute other) { + if (other == com.mysql.cj.x.protobuf.MysqlxPrepare.Execute.getDefaultInstance()) return this; + if (other.hasStmtId()) { + setStmtId(other.getStmtId()); + } + if (argsBuilder_ == null) { + if (!other.args_.isEmpty()) { + if (args_.isEmpty()) { + args_ = other.args_; + bitField0_ = (bitField0_ & ~0x00000002); + } else { + ensureArgsIsMutable(); + args_.addAll(other.args_); + } + onChanged(); + } + } else { + if (!other.args_.isEmpty()) { + if (argsBuilder_.isEmpty()) { + argsBuilder_.dispose(); + argsBuilder_ = null; + args_ = other.args_; + bitField0_ = (bitField0_ & ~0x00000002); + argsBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getArgsFieldBuilder() : null; + } else { + argsBuilder_.addAllMessages(other.args_); + } + } + } + if (other.hasCompactMetadata()) { + setCompactMetadata(other.getCompactMetadata()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasStmtId()) { + return false; + } + for (int i = 0; i < getArgsCount(); i++) { + if (!getArgs(i).isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxPrepare.Execute parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxPrepare.Execute) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int stmtId_ ; + /** + * 
+       ** client side assigned statement id, must be already prepared 
+       *
+ * + * required uint32 stmt_id = 1; + * @return Whether the stmtId field is set. + */ + public boolean hasStmtId() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** client side assigned statement id, must be already prepared 
+       *
+ * + * required uint32 stmt_id = 1; + * @return The stmtId. + */ + public int getStmtId() { + return stmtId_; + } + /** + * 
+       ** client side assigned statement id, must be already prepared 
+       *
+ * + * required uint32 stmt_id = 1; + * @param value The stmtId to set. + * @return This builder for chaining. + */ + public Builder setStmtId(int value) { + bitField0_ |= 0x00000001; + stmtId_ = value; + onChanged(); + return this; + } + /** + * 
+       ** client side assigned statement id, must be already prepared 
+       *
+ * + * required uint32 stmt_id = 1; + * @return This builder for chaining. + */ + public Builder clearStmtId() { + bitField0_ = (bitField0_ & ~0x00000001); + stmtId_ = 0; + onChanged(); + return this; + } + + private java.util.List args_ = + java.util.Collections.emptyList(); + private void ensureArgsIsMutable() { + if (!((bitField0_ & 0x00000002) != 0)) { + args_ = new java.util.ArrayList(args_); + bitField0_ |= 0x00000002; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder> argsBuilder_; + + /** + * 
+       ** Arguments to bind to the prepared statement 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public java.util.List getArgsList() { + if (argsBuilder_ == null) { + return java.util.Collections.unmodifiableList(args_); + } else { + return argsBuilder_.getMessageList(); + } + } + /** + * 
+       ** Arguments to bind to the prepared statement 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public int getArgsCount() { + if (argsBuilder_ == null) { + return args_.size(); + } else { + return argsBuilder_.getCount(); + } + } + /** + * 
+       ** Arguments to bind to the prepared statement 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any getArgs(int index) { + if (argsBuilder_ == null) { + return args_.get(index); + } else { + return argsBuilder_.getMessage(index); + } + } + /** + * 
+       ** Arguments to bind to the prepared statement 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public Builder setArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any value) { + if (argsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgsIsMutable(); + args_.set(index, value); + onChanged(); + } else { + argsBuilder_.setMessage(index, value); + } + return this; + } + /** + * 
+       ** Arguments to bind to the prepared statement 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public Builder setArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder builderForValue) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.set(index, builderForValue.build()); + onChanged(); + } else { + argsBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** Arguments to bind to the prepared statement 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public Builder addArgs(com.mysql.cj.x.protobuf.MysqlxDatatypes.Any value) { + if (argsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgsIsMutable(); + args_.add(value); + onChanged(); + } else { + argsBuilder_.addMessage(value); + } + return this; + } + /** + * 
+       ** Arguments to bind to the prepared statement 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public Builder addArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any value) { + if (argsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgsIsMutable(); + args_.add(index, value); + onChanged(); + } else { + argsBuilder_.addMessage(index, value); + } + return this; + } + /** + * 
+       ** Arguments to bind to the prepared statement 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public Builder addArgs( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder builderForValue) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.add(builderForValue.build()); + onChanged(); + } else { + argsBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * 
+       ** Arguments to bind to the prepared statement 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public Builder addArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder builderForValue) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.add(index, builderForValue.build()); + onChanged(); + } else { + argsBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** Arguments to bind to the prepared statement 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public Builder addAllArgs( + java.lang.Iterable values) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, args_); + onChanged(); + } else { + argsBuilder_.addAllMessages(values); + } + return this; + } + /** + * 
+       ** Arguments to bind to the prepared statement 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public Builder clearArgs() { + if (argsBuilder_ == null) { + args_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000002); + onChanged(); + } else { + argsBuilder_.clear(); + } + return this; + } + /** + * 
+       ** Arguments to bind to the prepared statement 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public Builder removeArgs(int index) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.remove(index); + onChanged(); + } else { + argsBuilder_.remove(index); + } + return this; + } + /** + * 
+       ** Arguments to bind to the prepared statement 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder getArgsBuilder( + int index) { + return getArgsFieldBuilder().getBuilder(index); + } + /** + * 
+       ** Arguments to bind to the prepared statement 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder getArgsOrBuilder( + int index) { + if (argsBuilder_ == null) { + return args_.get(index); } else { + return argsBuilder_.getMessageOrBuilder(index); + } + } + /** + * 
+       ** Arguments to bind to the prepared statement 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public java.util.List + getArgsOrBuilderList() { + if (argsBuilder_ != null) { + return argsBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(args_); + } + } + /** + * 
+       ** Arguments to bind to the prepared statement 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder addArgsBuilder() { + return getArgsFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.getDefaultInstance()); + } + /** + * 
+       ** Arguments to bind to the prepared statement 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder addArgsBuilder( + int index) { + return getArgsFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.getDefaultInstance()); + } + /** + * 
+       ** Arguments to bind to the prepared statement 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public java.util.List + getArgsBuilderList() { + return getArgsFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder> + getArgsFieldBuilder() { + if (argsBuilder_ == null) { + argsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder>( + args_, + ((bitField0_ & 0x00000002) != 0), + getParentForChildren(), + isClean()); + args_ = null; + } + return argsBuilder_; + } + + private boolean compactMetadata_ ; + /** + * 
+       ** send only type information for
+       *@ref Mysqlx::Resultset::ColumnMetaData, skipping names and others 
+       *
+ * + * optional bool compact_metadata = 3 [default = false]; + * @return Whether the compactMetadata field is set. + */ + public boolean hasCompactMetadata() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+       ** send only type information for
+       *@ref Mysqlx::Resultset::ColumnMetaData, skipping names and others 
+       *
+ * + * optional bool compact_metadata = 3 [default = false]; + * @return The compactMetadata. + */ + public boolean getCompactMetadata() { + return compactMetadata_; + } + /** + * 
+       ** send only type information for
+       *@ref Mysqlx::Resultset::ColumnMetaData, skipping names and others 
+       *
+ * + * optional bool compact_metadata = 3 [default = false]; + * @param value The compactMetadata to set. + * @return This builder for chaining. + */ + public Builder setCompactMetadata(boolean value) { + bitField0_ |= 0x00000004; + compactMetadata_ = value; + onChanged(); + return this; + } + /** + * 
+       ** send only type information for
+       *@ref Mysqlx::Resultset::ColumnMetaData, skipping names and others 
+       *
+ * + * optional bool compact_metadata = 3 [default = false]; + * @return This builder for chaining. + */ + public Builder clearCompactMetadata() { + bitField0_ = (bitField0_ & ~0x00000004); + compactMetadata_ = false; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Prepare.Execute) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Prepare.Execute) + private static final com.mysql.cj.x.protobuf.MysqlxPrepare.Execute DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxPrepare.Execute(); + } + + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Execute getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Execute parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Execute(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxPrepare.Execute getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface DeallocateOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Prepare.Deallocate) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** client side assigned statement id, must be already prepared 
+     *
+ * + * required uint32 stmt_id = 1; + * @return Whether the stmtId field is set. + */ + boolean hasStmtId(); + /** + * 
+     ** client side assigned statement id, must be already prepared 
+     *
+ * + * required uint32 stmt_id = 1; + * @return The stmtId. + */ + int getStmtId(); + } + /** + * 
+   **
+   *Deallocate already prepared statement
+   *@startuml
+   *client -> server: Deallocate
+   *alt Success
+   *client <- server: Ok
+   *else Failure
+   *client <- server: Error
+   *end
+   *@enduml
+   *@returns @ref Mysqlx::Ok or @ref Mysqlx::Error
+   *
+ * + * Protobuf type {@code Mysqlx.Prepare.Deallocate} + */ + public static final class Deallocate extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Prepare.Deallocate) + DeallocateOrBuilder { + private static final long serialVersionUID = 0L; + // Use Deallocate.newBuilder() to construct. + private Deallocate(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Deallocate() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Deallocate(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Deallocate( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + bitField0_ |= 0x00000001; + stmtId_ = input.readUInt32(); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.internal_static_Mysqlx_Prepare_Deallocate_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.internal_static_Mysqlx_Prepare_Deallocate_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate.class, com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate.Builder.class); + } + + private int bitField0_; + public static final int STMT_ID_FIELD_NUMBER = 1; + private int stmtId_; + /** + * 
+     ** client side assigned statement id, must be already prepared 
+     *
+ * + * required uint32 stmt_id = 1; + * @return Whether the stmtId field is set. + */ + public boolean hasStmtId() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** client side assigned statement id, must be already prepared 
+     *
+ * + * required uint32 stmt_id = 1; + * @return The stmtId. + */ + public int getStmtId() { + return stmtId_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasStmtId()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeUInt32(1, stmtId_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(1, stmtId_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate other = (com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate) obj; + + if (hasStmtId() != other.hasStmtId()) return false; + if (hasStmtId()) { + if (getStmtId() + != other.getStmtId()) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasStmtId()) { + hash = (37 * hash) + STMT_ID_FIELD_NUMBER; + hash = (53 * hash) + getStmtId(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Deallocate already prepared statement
+     *@startuml
+     *client -> server: Deallocate
+     *alt Success
+     *client <- server: Ok
+     *else Failure
+     *client <- server: Error
+     *end
+     *@enduml
+     *@returns @ref Mysqlx::Ok or @ref Mysqlx::Error
+     *
+ * + * Protobuf type {@code Mysqlx.Prepare.Deallocate} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Prepare.Deallocate) + com.mysql.cj.x.protobuf.MysqlxPrepare.DeallocateOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.internal_static_Mysqlx_Prepare_Deallocate_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.internal_static_Mysqlx_Prepare_Deallocate_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate.class, com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + stmtId_ = 0; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.internal_static_Mysqlx_Prepare_Deallocate_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate build() { + com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate buildPartial() { + com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate result = new com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.stmtId_ = stmtId_; + to_bitField0_ |= 0x00000001; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate other) { + if (other == com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate.getDefaultInstance()) return this; + if (other.hasStmtId()) { + setStmtId(other.getStmtId()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasStmtId()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int stmtId_ ; + /** + * 
+       ** client side assigned statement id, must be already prepared 
+       *
+ * + * required uint32 stmt_id = 1; + * @return Whether the stmtId field is set. + */ + public boolean hasStmtId() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** client side assigned statement id, must be already prepared 
+       *
+ * + * required uint32 stmt_id = 1; + * @return The stmtId. + */ + public int getStmtId() { + return stmtId_; + } + /** + * 
+       ** client side assigned statement id, must be already prepared 
+       *
+ * + * required uint32 stmt_id = 1; + * @param value The stmtId to set. + * @return This builder for chaining. + */ + public Builder setStmtId(int value) { + bitField0_ |= 0x00000001; + stmtId_ = value; + onChanged(); + return this; + } + /** + * 
+       ** client side assigned statement id, must be already prepared 
+       *
+ * + * required uint32 stmt_id = 1; + * @return This builder for chaining. + */ + public Builder clearStmtId() { + bitField0_ = (bitField0_ & ~0x00000001); + stmtId_ = 0; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Prepare.Deallocate) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Prepare.Deallocate) + private static final com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate(); + } + + public static com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Deallocate parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Deallocate(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxPrepare.Deallocate getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Prepare_Prepare_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Prepare_Prepare_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Prepare_Prepare_OneOfMessage_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Prepare_Prepare_OneOfMessage_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Prepare_Execute_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Prepare_Execute_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Prepare_Deallocate_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Prepare_Deallocate_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\024mysqlx_prepare.proto\022\016Mysqlx.Prepare\032\014" + + "mysqlx.proto\032\020mysqlx_sql.proto\032\021mysqlx_c" + + "rud.proto\032\026mysqlx_datatypes.proto\"\235\003\n\007Pr" + + "epare\022\017\n\007stmt_id\030\001 \002(\r\0222\n\004stmt\030\002 \002(\0132$.M" + + "ysqlx.Prepare.Prepare.OneOfMessage\032\306\002\n\014O" + + "neOfMessage\0227\n\004type\030\001 \002(\0162).Mysqlx.Prepa" + + "re.Prepare.OneOfMessage.Type\022\037\n\004find\030\002 \001" + + "(\0132\021.Mysqlx.Crud.Find\022#\n\006insert\030\003 \001(\0132\023." + + "Mysqlx.Crud.Insert\022#\n\006update\030\004 \001(\0132\023.Mys" + + "qlx.Crud.Update\022#\n\006delete\030\005 \001(\0132\023.Mysqlx" + + ".Crud.Delete\022-\n\014stmt_execute\030\006 \001(\0132\027.Mys" + + "qlx.Sql.StmtExecute\">\n\004Type\022\010\n\004FIND\020\000\022\n\n" + + "\006INSERT\020\001\022\n\n\006UPDATE\020\002\022\n\n\006DELETE\020\004\022\010\n\004STM" + + "T\020\005:\004\210\3520(\"f\n\007Execute\022\017\n\007stmt_id\030\001 \002(\r\022#\n" + + "\004args\030\002 \003(\0132\025.Mysqlx.Datatypes.Any\022\037\n\020co" + + "mpact_metadata\030\003 \001(\010:\005false:\004\210\3520)\"#\n\nDea" + + "llocate\022\017\n\007stmt_id\030\001 \002(\r:\004\210\3520*B\031\n\027com.my" + + "sql.cj.x.protobuf" + }; + descriptor = com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + com.mysql.cj.x.protobuf.Mysqlx.getDescriptor(), + com.mysql.cj.x.protobuf.MysqlxSql.getDescriptor(), + com.mysql.cj.x.protobuf.MysqlxCrud.getDescriptor(), + com.mysql.cj.x.protobuf.MysqlxDatatypes.getDescriptor(), + }); + internal_static_Mysqlx_Prepare_Prepare_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_Mysqlx_Prepare_Prepare_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Prepare_Prepare_descriptor, + new java.lang.String[] { "StmtId", "Stmt", }); + internal_static_Mysqlx_Prepare_Prepare_OneOfMessage_descriptor = + internal_static_Mysqlx_Prepare_Prepare_descriptor.getNestedTypes().get(0); + internal_static_Mysqlx_Prepare_Prepare_OneOfMessage_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Prepare_Prepare_OneOfMessage_descriptor, + new java.lang.String[] { "Type", "Find", "Insert", "Update", "Delete", "StmtExecute", }); + internal_static_Mysqlx_Prepare_Execute_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_Mysqlx_Prepare_Execute_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Prepare_Execute_descriptor, + new java.lang.String[] { "StmtId", "Args", "CompactMetadata", }); + internal_static_Mysqlx_Prepare_Deallocate_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_Mysqlx_Prepare_Deallocate_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Prepare_Deallocate_descriptor, + new java.lang.String[] { "StmtId", }); + com.google.protobuf.ExtensionRegistry registry = + com.google.protobuf.ExtensionRegistry.newInstance(); + registry.add(com.mysql.cj.x.protobuf.Mysqlx.clientMessageId); + com.google.protobuf.Descriptors.FileDescriptor + .internalUpdateFileDescriptor(descriptor, registry); + com.mysql.cj.x.protobuf.Mysqlx.getDescriptor(); + com.mysql.cj.x.protobuf.MysqlxSql.getDescriptor(); + com.mysql.cj.x.protobuf.MysqlxCrud.getDescriptor(); + com.mysql.cj.x.protobuf.MysqlxDatatypes.getDescriptor(); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxResultset.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxResultset.java new file mode 100644 index 0000000..ec1b6f8 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxResultset.java @@ -0,0 +1,5600 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.x.protobuf; + +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: mysqlx_resultset.proto + +public final class MysqlxResultset { + private MysqlxResultset() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + /** + * 
+   **
+   *A hint about the higher-level encoding of a BYTES field
+   *|type  | value  | description             |
+   *|------| -------|-------------------------|
+   *|BYTES | 0x0001 | GEOMETRY (WKB encoding) |
+   *|BYTES | 0x0002 | JSON (text encoding)    |
+   *|BYTES | 0x0003 | XML (text encoding)     |
+   *@note
+   *this list isn't comprehensive. As guideline: the field's value is expected
+   *to pass a validator check on client and server if this field is set.
+   *If the server adds more internal datatypes that rely on BLOB storage
+   *like image manipulation, seeking into complex types in BLOBs, ... more
+   *types will be added.
+   *
+ * + * Protobuf enum {@code Mysqlx.Resultset.ContentType_BYTES} + */ + public enum ContentType_BYTES + implements com.google.protobuf.ProtocolMessageEnum { + /** + * GEOMETRY = 1; + */ + GEOMETRY(1), + /** + * JSON = 2; + */ + JSON(2), + /** + * XML = 3; + */ + XML(3), + ; + + /** + * GEOMETRY = 1; + */ + public static final int GEOMETRY_VALUE = 1; + /** + * JSON = 2; + */ + public static final int JSON_VALUE = 2; + /** + * XML = 3; + */ + public static final int XML_VALUE = 3; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static ContentType_BYTES valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static ContentType_BYTES forNumber(int value) { + switch (value) { + case 1: return GEOMETRY; + case 2: return JSON; + case 3: return XML; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + ContentType_BYTES> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public ContentType_BYTES findValueByNumber(int number) { + return ContentType_BYTES.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxResultset.getDescriptor().getEnumTypes().get(0); + } + + private static final ContentType_BYTES[] VALUES = values(); + + public static ContentType_BYTES valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private ContentType_BYTES(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Resultset.ContentType_BYTES) + } + + /** + * 
+   **
+   *A hint about the higher-level encoding of a DATETIME field
+   *|type     |value  |description                                |
+   *|---------|-------|-------------------------------------------|
+   *|DATE     |0x0001 |DATETIME contains only date part           |
+   *|DATETIME |0x0002 |DATETIME contains both date and time parts |
+   *
+ * + * Protobuf enum {@code Mysqlx.Resultset.ContentType_DATETIME} + */ + public enum ContentType_DATETIME + implements com.google.protobuf.ProtocolMessageEnum { + /** + * DATE = 1; + */ + DATE(1), + /** + * DATETIME = 2; + */ + DATETIME(2), + ; + + /** + * DATE = 1; + */ + public static final int DATE_VALUE = 1; + /** + * DATETIME = 2; + */ + public static final int DATETIME_VALUE = 2; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static ContentType_DATETIME valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static ContentType_DATETIME forNumber(int value) { + switch (value) { + case 1: return DATE; + case 2: return DATETIME; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + ContentType_DATETIME> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public ContentType_DATETIME findValueByNumber(int number) { + return ContentType_DATETIME.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxResultset.getDescriptor().getEnumTypes().get(1); + } + + private static final ContentType_DATETIME[] VALUES = values(); + + public static ContentType_DATETIME valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private ContentType_DATETIME(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Resultset.ContentType_DATETIME) + } + + public interface FetchDoneMoreOutParamsOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Resultset.FetchDoneMoreOutParams) + com.google.protobuf.MessageOrBuilder { + } + /** + * 
+   **
+   *Resultsets are finished, OUT paramset is next:
+   *
+ * + * Protobuf type {@code Mysqlx.Resultset.FetchDoneMoreOutParams} + */ + public static final class FetchDoneMoreOutParams extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Resultset.FetchDoneMoreOutParams) + FetchDoneMoreOutParamsOrBuilder { + private static final long serialVersionUID = 0L; + // Use FetchDoneMoreOutParams.newBuilder() to construct. + private FetchDoneMoreOutParams(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private FetchDoneMoreOutParams() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new FetchDoneMoreOutParams(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private FetchDoneMoreOutParams( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_FetchDoneMoreOutParams_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_FetchDoneMoreOutParams_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams.class, com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams.Builder.class); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams other = (com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams) obj; + + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Resultsets are finished, OUT paramset is next:
+     *
+ * + * Protobuf type {@code Mysqlx.Resultset.FetchDoneMoreOutParams} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Resultset.FetchDoneMoreOutParams) + com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParamsOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_FetchDoneMoreOutParams_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_FetchDoneMoreOutParams_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams.class, com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_FetchDoneMoreOutParams_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams build() { + com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams buildPartial() { + com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams result = new com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams(this); + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams other) { + if (other == com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams.getDefaultInstance()) return this; + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Resultset.FetchDoneMoreOutParams) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Resultset.FetchDoneMoreOutParams) + private static final com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams(); + } + + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public FetchDoneMoreOutParams parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new FetchDoneMoreOutParams(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreOutParams getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface FetchDoneMoreResultsetsOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Resultset.FetchDoneMoreResultsets) + com.google.protobuf.MessageOrBuilder { + } + /** + * 
+   **
+   *Resultset and out-params are finished, but more resultsets available
+   *
+ * + * Protobuf type {@code Mysqlx.Resultset.FetchDoneMoreResultsets} + */ + public static final class FetchDoneMoreResultsets extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Resultset.FetchDoneMoreResultsets) + FetchDoneMoreResultsetsOrBuilder { + private static final long serialVersionUID = 0L; + // Use FetchDoneMoreResultsets.newBuilder() to construct. + private FetchDoneMoreResultsets(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private FetchDoneMoreResultsets() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new FetchDoneMoreResultsets(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private FetchDoneMoreResultsets( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_FetchDoneMoreResultsets_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_FetchDoneMoreResultsets_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets.class, com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets.Builder.class); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets other = (com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets) obj; + + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Resultset and out-params are finished, but more resultsets available
+     *
+ * + * Protobuf type {@code Mysqlx.Resultset.FetchDoneMoreResultsets} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Resultset.FetchDoneMoreResultsets) + com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsetsOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_FetchDoneMoreResultsets_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_FetchDoneMoreResultsets_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets.class, com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_FetchDoneMoreResultsets_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets build() { + com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets buildPartial() { + com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets result = new com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets(this); + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets other) { + if (other == com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets.getDefaultInstance()) return this; + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Resultset.FetchDoneMoreResultsets) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Resultset.FetchDoneMoreResultsets) + private static final com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets(); + } + + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public FetchDoneMoreResultsets parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new FetchDoneMoreResultsets(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneMoreResultsets getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface FetchDoneOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Resultset.FetchDone) + com.google.protobuf.MessageOrBuilder { + } + /** + * 
+   **
+   *All resultsets are finished
+   *
+ * + * Protobuf type {@code Mysqlx.Resultset.FetchDone} + */ + public static final class FetchDone extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Resultset.FetchDone) + FetchDoneOrBuilder { + private static final long serialVersionUID = 0L; + // Use FetchDone.newBuilder() to construct. + private FetchDone(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private FetchDone() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new FetchDone(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private FetchDone( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_FetchDone_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_FetchDone_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone.class, com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone.Builder.class); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone other = (com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone) obj; + + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *All resultsets are finished
+     *
+ * + * Protobuf type {@code Mysqlx.Resultset.FetchDone} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Resultset.FetchDone) + com.mysql.cj.x.protobuf.MysqlxResultset.FetchDoneOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_FetchDone_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_FetchDone_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone.class, com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_FetchDone_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone build() { + com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone buildPartial() { + com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone result = new com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone(this); + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone other) { + if (other == com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone.getDefaultInstance()) return this; + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Resultset.FetchDone) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Resultset.FetchDone) + private static final com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone(); + } + + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public FetchDone parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new FetchDone(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.FetchDone getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface FetchSuspendedOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Resultset.FetchSuspended) + com.google.protobuf.MessageOrBuilder { + } + /** + * 
+   **
+   *Cursor is opened still the execution of PrepFetch or PrepExecute ended
+   *
+ * + * Protobuf type {@code Mysqlx.Resultset.FetchSuspended} + */ + public static final class FetchSuspended extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Resultset.FetchSuspended) + FetchSuspendedOrBuilder { + private static final long serialVersionUID = 0L; + // Use FetchSuspended.newBuilder() to construct. + private FetchSuspended(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private FetchSuspended() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new FetchSuspended(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private FetchSuspended( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_FetchSuspended_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_FetchSuspended_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended.class, com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended.Builder.class); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended other = (com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended) obj; + + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Cursor is opened still the execution of PrepFetch or PrepExecute ended
+     *
+ * + * Protobuf type {@code Mysqlx.Resultset.FetchSuspended} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Resultset.FetchSuspended) + com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspendedOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_FetchSuspended_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_FetchSuspended_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended.class, com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_FetchSuspended_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended build() { + com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended buildPartial() { + com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended result = new com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended(this); + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended other) { + if (other == com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended.getDefaultInstance()) return this; + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Resultset.FetchSuspended) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Resultset.FetchSuspended) + private static final com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended(); + } + + public static com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public FetchSuspended parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new FetchSuspended(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.FetchSuspended getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ColumnMetaDataOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Resultset.ColumnMetaData) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** datatype of the field in a row 
+     *
+ * + * required .Mysqlx.Resultset.ColumnMetaData.FieldType type = 1; + * @return Whether the type field is set. + */ + boolean hasType(); + /** + * 
+     ** datatype of the field in a row 
+     *
+ * + * required .Mysqlx.Resultset.ColumnMetaData.FieldType type = 1; + * @return The type. + */ + com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData.FieldType getType(); + + /** + * 
+     ** ame of the column 
+     *
+ * + * optional bytes name = 2; + * @return Whether the name field is set. + */ + boolean hasName(); + /** + * 
+     ** ame of the column 
+     *
+ * + * optional bytes name = 2; + * @return The name. + */ + com.google.protobuf.ByteString getName(); + + /** + * 
+     ** name of the column before an alias was applied 
+     *
+ * + * optional bytes original_name = 3; + * @return Whether the originalName field is set. + */ + boolean hasOriginalName(); + /** + * 
+     ** name of the column before an alias was applied 
+     *
+ * + * optional bytes original_name = 3; + * @return The originalName. + */ + com.google.protobuf.ByteString getOriginalName(); + + /** + * 
+     ** name of the table the column originates from 
+     *
+ * + * optional bytes table = 4; + * @return Whether the table field is set. + */ + boolean hasTable(); + /** + * 
+     ** name of the table the column originates from 
+     *
+ * + * optional bytes table = 4; + * @return The table. + */ + com.google.protobuf.ByteString getTable(); + + /** + * 
+     ** name of the table the column originates from before an alias was applied 
+     *
+ * + * optional bytes original_table = 5; + * @return Whether the originalTable field is set. + */ + boolean hasOriginalTable(); + /** + * 
+     ** name of the table the column originates from before an alias was applied 
+     *
+ * + * optional bytes original_table = 5; + * @return The originalTable. + */ + com.google.protobuf.ByteString getOriginalTable(); + + /** + * 
+     ** schema the column originates from 
+     *
+ * + * optional bytes schema = 6; + * @return Whether the schema field is set. + */ + boolean hasSchema(); + /** + * 
+     ** schema the column originates from 
+     *
+ * + * optional bytes schema = 6; + * @return The schema. + */ + com.google.protobuf.ByteString getSchema(); + + /** + * 
+     ** catalog the schema originates from
+     *@note
+     *As there is current no support for catalogs in MySQL,
+     *don't expect this field to be set. In the MySQL C/S
+     *protocol the field had the value ``def`` all the time 
+     *
+ * + * optional bytes catalog = 7; + * @return Whether the catalog field is set. + */ + boolean hasCatalog(); + /** + * 
+     ** catalog the schema originates from
+     *@note
+     *As there is current no support for catalogs in MySQL,
+     *don't expect this field to be set. In the MySQL C/S
+     *protocol the field had the value ``def`` all the time 
+     *
+ * + * optional bytes catalog = 7; + * @return The catalog. + */ + com.google.protobuf.ByteString getCatalog(); + + /** + * optional uint64 collation = 8; + * @return Whether the collation field is set. + */ + boolean hasCollation(); + /** + * optional uint64 collation = 8; + * @return The collation. + */ + long getCollation(); + + /** + * 
+     ** displayed factional decimal digits for floating point and
+     *fixed point numbers 
+     *
+ * + * optional uint32 fractional_digits = 9; + * @return Whether the fractionalDigits field is set. + */ + boolean hasFractionalDigits(); + /** + * 
+     ** displayed factional decimal digits for floating point and
+     *fixed point numbers 
+     *
+ * + * optional uint32 fractional_digits = 9; + * @return The fractionalDigits. + */ + int getFractionalDigits(); + + /** + * 
+     ** maximum count of displayable characters of .type 
+     *
+ * + * optional uint32 length = 10; + * @return Whether the length field is set. + */ + boolean hasLength(); + /** + * 
+     ** maximum count of displayable characters of .type 
+     *
+ * + * optional uint32 length = 10; + * @return The length. + */ + int getLength(); + + /** + * 
+     ** ``.type`` specific flags
+     *| Type    | Value  | Description  |
+     *|---------|--------|--------------|
+     *| UINT    | 0x0001 | zerofill     |
+     *| DOUBLE  | 0x0001 | unsigned     |
+     *| FLOAT   | 0x0001 | unsigned     |
+     *| DECIMAL | 0x0001 | unsigned     |
+     *| BYTES   | 0x0001 | rightpad     |
+     *| Value  | Description     |
+     *|--------|-----------------|
+     *| 0x0010 | NOT\_NULL       |
+     *| 0x0020 | PRIMARY\_KEY    |
+     *| 0x0040 | UNIQUE\_KEY     |
+     *| 0x0080 | MULTIPLE\_KEY   |
+     *| 0x0100 | AUTO\_INCREMENT |
+     *default: 0 
+     *
+ * + * optional uint32 flags = 11; + * @return Whether the flags field is set. + */ + boolean hasFlags(); + /** + * 
+     ** ``.type`` specific flags
+     *| Type    | Value  | Description  |
+     *|---------|--------|--------------|
+     *| UINT    | 0x0001 | zerofill     |
+     *| DOUBLE  | 0x0001 | unsigned     |
+     *| FLOAT   | 0x0001 | unsigned     |
+     *| DECIMAL | 0x0001 | unsigned     |
+     *| BYTES   | 0x0001 | rightpad     |
+     *| Value  | Description     |
+     *|--------|-----------------|
+     *| 0x0010 | NOT\_NULL       |
+     *| 0x0020 | PRIMARY\_KEY    |
+     *| 0x0040 | UNIQUE\_KEY     |
+     *| 0x0080 | MULTIPLE\_KEY   |
+     *| 0x0100 | AUTO\_INCREMENT |
+     *default: 0 
+     *
+ * + * optional uint32 flags = 11; + * @return The flags. + */ + int getFlags(); + + /** + * 
+     ** a hint about the higher-level encoding of a BYTES field
+     *| Type   | Value  | Description             |
+     *|--------|--------|-------------------------|
+     *| BYTES  | 0x0001 | GEOMETRY (WKB encoding) |
+     *| BYTES  | 0x0002 | JSON (text encoding)    |
+     *| BYTES  | 0x0003 | XML (text encoding)     |
+     *@note
+     *This list isn't comprehensive. As guideline: the field's
+     *value is expected to pass a validator check on client
+     *and server if this field is set. If the server adds more
+     *internal data types that rely on BLOB storage like image
+     *manipulation, seeking into complex types in BLOBs, and
+     *more types will be added 
+     *
+ * + * optional uint32 content_type = 12; + * @return Whether the contentType field is set. + */ + boolean hasContentType(); + /** + * 
+     ** a hint about the higher-level encoding of a BYTES field
+     *| Type   | Value  | Description             |
+     *|--------|--------|-------------------------|
+     *| BYTES  | 0x0001 | GEOMETRY (WKB encoding) |
+     *| BYTES  | 0x0002 | JSON (text encoding)    |
+     *| BYTES  | 0x0003 | XML (text encoding)     |
+     *@note
+     *This list isn't comprehensive. As guideline: the field's
+     *value is expected to pass a validator check on client
+     *and server if this field is set. If the server adds more
+     *internal data types that rely on BLOB storage like image
+     *manipulation, seeking into complex types in BLOBs, and
+     *more types will be added 
+     *
+ * + * optional uint32 content_type = 12; + * @return The contentType. + */ + int getContentType(); + } + /** + * 
+   **
+   *Meta data of a column
+   *@note
+   *The encoding used for the different ``bytes`` fields in the
+   *meta data is externally controlled. See also:
+   *https://dev.mysql.com/doc/refman/5.0/en/charset-connection.html
+   *@par
+   *@note
+   *The server may not set the ``original_{table|name}`` fields
+   *if they are equal to the plain ``{table|name}`` field.
+   *@par
+   *@note
+   *A client has to reconstruct it like:
+   *@code{py}
+   *if .original_name is empty and .name is not empty:
+   *.original_name = .name
+   *if .original_table is empty and .table is not empty:
+   *.original_table = .table
+   *@endcode
+   *@par
+   *@note
+   *``Compact metadata format`` can be requested by the client.
+   *In that case, only ``.type`` is set and all other fields are  empty.
+   *Expected data type of Mysqlx.Resultset.Row per SQL Type for
+   *non-NULL values:
+   *| SQL Type          | .type     | .length | .frac\_dig | .flags | .charset |
+   *|-------------------|-----------|---------|------------|--------|----------|
+   *| TINY              | SINT      | x       |            |        |          |
+   *| TINY UNSIGNED     | UINT      | x       |            | x      |          |
+   *| SHORT             | SINT      | x       |            |        |          |
+   *| SHORT UNSIGNED    | UINT      | x       |            | x      |          |
+   *| INT24             | SINT      | x       |            |        |          |
+   *| INT24 UNSIGNED    | UINT      | x       |            | x      |          |
+   *| INT               | SINT      | x       |            |        |          |
+   *| INT UNSIGNED      | UINT      | x       |            | x      |          |
+   *| LONGLONG          | SINT      | x       |            |        |          |
+   *| LONGLONG UNSIGNED | UINT      | x       |            | x      |          |
+   *| DOUBLE            | DOUBLE    | x       | x          | x      |          |
+   *| FLOAT             | FLOAT     | x       | x          | x      |          |
+   *| DECIMAL           | DECIMAL   | x       | x          | x      |          |
+   *| VARCHAR,CHAR,...  | BYTES     | x       |            | x      | x        |
+   *| GEOMETRY          | BYTES     |         |            |        |          |
+   *| TIME              | TIME      | x       |            |        |          |
+   *| DATE              | DATETIME  | x       |            |        |          |
+   *| DATETIME          | DATETIME  | x       |            |        |          |
+   *| YEAR              | UINT      | x       |            | x      |          |
+   *| TIMESTAMP         | DATETIME  | x       |            |        |          |
+   *| SET               | SET       |         |            |        | x        |
+   *| ENUM              | ENUM      |         |            |        | x        |
+   *| NULL              | BYTES     |         |            |        |          |
+   *| BIT               | BIT       | x       |            |        |          |
+   *@note
+   *The SQL "NULL" value is sent as an empty field value in
+   *@ref Mysqlx::Resultset::Row.
+   *@par Tip
+   *The protobuf encoding of primitive data types is described in
+   *https://developers.google.com/protocol-buffers/docs/encoding
+   *+ SINT
+   *- ``.length`` @n
+   *Maximum number of displayable decimal digits (including
+   *minus sign) of the type.
+   *@note
+   *The valid range is 0-255, but usually you'll see 1-20.
+   *| SQL Type         | Maximum Digits per Type |
+   *|------------------|-------------------------|
+   *| TINY SIGNED      | 4                       |
+   *| SHORT SIGNED     | 6                       |
+   *| INT24 SIGNED     | 8                       |
+   *| INT SIGNED       | 11                      |
+   *| LONGLONG SIGNED  | 20                      |
+   *@par Tip
+   *Definition of ``M`` are in
+   *https://dev.mysql.com/doc/refman/5.5/en/numeric-type-overview.html.
+   *- ``value``@n
+   *Variable length encoded signed 64 integer.
+   *+ UINT
+   *- ``.flags & 1`` (zerofill) @n
+   *The client has to left pad with 0's up to .length.
+   *- ``.length`` @n
+   *Maximum number of displayable decimal digits of the
+   *type.
+   *@note
+   *The valid range is 0-255, but usually you'll see
+   *1-20.
+   *| SQL Type             | max digits per type |
+   *|----------------------|---------------------|
+   *| TINY UNSIGNED        | 3                   |
+   *| SHORT UNSIGNED       | 5                   |
+   *| INT24 UNSIGNED       | 8                   |
+   *| INT UNSIGNED         | 10                  |
+   *| LONGLONG UNSIGNED    | 20                  |
+   *@par Tip
+   *Definition of ``M`` are in
+   *https://dev.mysql.com/doc/refman/5.5/en/numeric-type-overview.html.
+   *- ``value`` @n
+   *Variable length encoded unsigned 64 integer.
+   *+ BIT
+   *- ``.length`` @n
+   *Maximum number of displayable binary digits.
+   *@note
+   *The valid range for M of the ``BIT`` type is 1 - 64.
+   *@par Tip
+   *https://dev.mysql.com/doc/refman/5.5/en/numeric-type-overview.html
+   *- ``value`` @n
+   *Variable length encoded unsigned 64 integer.
+   *+ DOUBLE
+   *- ``.length`` @n
+   *Maximum number of displayable decimal digits (including
+   *the decimal point and ``.fractional_digits``).
+   *- ``.fractional_digits`` @n
+   *Maximum number of displayable decimal digits following
+   *the decimal point.
+   *- ``value``@n
+   *Encoded as protobuf's 'double'.
+   *+ FLOAT
+   *- ``.length``@n
+   *Maximum number of displayable decimal digits (including
+   *the decimal point and ``.fractional_digits``).
+   *- ``.fractional_digits``@n
+   *Maximum number of displayable decimal digits following
+   *the decimal point.
+   *- ``value``@n
+   *Encoded as protobuf's 'float'.
+   *+ BYTES, ENUM
+   *@note
+   *BYTES is used for all opaque byte strings that may have a charset:
+   *-  TINYBLOB, BLOB, MEDIUMBLOB, LONGBLOB
+   *-  TINYTEXT, TEXT, MEDIUMTEXT, LONGTEXT
+   *-  VARCHAR, VARBINARY
+   *-  CHAR, BINARY
+   *-  ENUM
+   *- ``.length``@n
+   *Maximum length of characters of the underlying type.
+   *- ``.flags & 1`` (rightpad) @n
+   *If the length of the field is less than ``.length``, the
+   *receiver is supposed to add padding characters to the
+   *right end of the string. If the ``.charset`` is
+   *"binary", the padding character is ``0x00``, otherwise
+   *it is a space character as defined by that character
+   *set.
+   *| SQL Type      | .length  | .charset  | .flags   |
+   *|---------------|----------|-----------|----------|
+   *| TINYBLOB      | 256      | binary    |          |
+   *| BLOB          | 65535    | binary    |          |
+   *| VARCHAR(32)   | 32       | utf8      |          |
+   *| VARBINARY(32) | 32       | utf8\_bin |          |
+   *| BINARY(32)    | 32       | binary    | rightpad |
+   *| CHAR(32)      | 32       | utf8      | rightpad |
+   *- ``value``
+   *Sequence of bytes with added one extra ``0x00`` byte at
+   *the end. To obtain the original string, the extra
+   *``0x00`` should be removed. The length of the string can
+   *be acquired with protobuf's field ``length()`` method:
+   *``length of sequence-of-bytes = length-of-field - 1``
+   *@note
+   *The extra byte allows to distinguish between a NULL
+   *and empty byte sequence.
+   *+ TIME
+   *A time value.
+   *- ``value``@n
+   *The following bytes sequence:
+   *``negate [ hour [ minutes [ seconds [ useconds ]]]]``
+   *-  negate - one byte, should be one of: 0x00 for "+",
+   *0x01 for "-"
+   *-  hour - optional variable length encoded unsigned64
+   *value for the hour
+   *-  minutes - optional variable length encoded unsigned64
+   *value for the minutes
+   *-  seconds - optional variable length encoded unsigned64
+   *value for the seconds
+   *-  useconds - optional variable length encoded
+   *unsigned64 value for the microseconds
+   *@par Tip
+   *The protobuf encoding in
+   *https://developers.google.com/protocol-buffers/docs/encoding.
+   *@note
+   *Hour, minutes, seconds, and useconds are optional if
+   *all the values to the right are 0.
+   *Example: ``0x00 -> +00:00:00.000000``
+   *+ DATETIME
+   *A date or date and time value.
+   *- ``value`` @n
+   *A sequence of variants, arranged as follows:
+   *``| year | month | day | [ | hour | [ | minutes | [ | seconds | [ | useconds | ]]]]``
+   *-  year - variable length encoded unsigned64 value for
+   *the year
+   *-  month - variable length encoded unsigned64 value for
+   *the month
+   *-  day - variable length encoded unsigned64 value for
+   *the day
+   *-  hour - optional variable length encoded unsigned64
+   *value for the hour
+   *-  minutes - optional variable length encoded unsigned64
+   *value for the minutes
+   *-  seconds - optional variable length encoded unsigned64
+   *value for the seconds
+   *-  useconds - optional variable length encoded
+   *unsigned64 value for the microseconds
+   *@note
+   *Hour, minutes, seconds, useconds are optional if all
+   *the values to the right are 0.
+   *- ``.flags``@n
+   *| Name          | Position |
+   *|---------------|----------|
+   *| is\_timestamp | 1        |
+   *+ DECIMAL
+   *An arbitrary length number. The number is encoded as a
+   *single byte indicating the position of the decimal point
+   *followed by the Packed BCD encoded number. Packed BCD is
+   *used to simplify conversion to and from strings and other
+   *native arbitrary precision math data types. See also: packed
+   *BCD in https://en.wikipedia.org/wiki/Binary-coded_decimal
+   *- ``.length``
+   *Maximum number of displayable decimal digits
+   *(*excluding* the decimal point and sign, but including
+   *``.fractional_digits``).
+   *@note
+   *Should be in the range of 1 - 65.
+   *- ``.fractional_digits``
+   *The decimal digits to display out of length.
+   *@note
+   *Should be in the range of 0 - 30.
+   *``value``
+   *The following bytes sequence:
+   *``scale | BCD+ sign [0x00]?``
+   *-  scale - 8bit scale value (number of decimal digit after the '.')
+   *-  BCD - BCD encoded digits (4 bits for each digit)
+   *-  sign - sign encoded on 4 bits (0xc = "+", 0xd = "-")
+   *-  0x0 - last 4bits if length(digits) % 2 == 0
+   *Example: ``x04 0x12 0x34 0x01
+   *0xd0 -> -12.3401``
+   *+ SET
+   *A list of strings representing a SET of values.
+   *- ``value``@n
+   *A sequence of 0 or more of protobuf's bytes (length
+   *prepended octets) or one of the special sequences with a
+   *predefined meaning listed below.
+   *Example (length of the bytes array shown in brackets):
+   *-  ``[0]`` - the NULL value
+   *-  ``[1] 0x00`` - a set containing a blank string ''
+   *-  ``[1] 0x01`` - this would be an invalid value,
+   *but is to be treated as the empty set
+   *-  ``[2] 0x01 0x00`` - a set with a single item, which is the '0'
+   *character
+   *-  ``[8] 0x03 F O O 0x03 B A R`` - a set with 2 items: FOO,BAR
+   *
+ * + * Protobuf type {@code Mysqlx.Resultset.ColumnMetaData} + */ + public static final class ColumnMetaData extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Resultset.ColumnMetaData) + ColumnMetaDataOrBuilder { + private static final long serialVersionUID = 0L; + // Use ColumnMetaData.newBuilder() to construct. + private ColumnMetaData(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private ColumnMetaData() { + type_ = 1; + name_ = com.google.protobuf.ByteString.EMPTY; + originalName_ = com.google.protobuf.ByteString.EMPTY; + table_ = com.google.protobuf.ByteString.EMPTY; + originalTable_ = com.google.protobuf.ByteString.EMPTY; + schema_ = com.google.protobuf.ByteString.EMPTY; + catalog_ = com.google.protobuf.ByteString.EMPTY; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new ColumnMetaData(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private ColumnMetaData( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + int rawValue = input.readEnum(); + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData.FieldType value = com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData.FieldType.valueOf(rawValue); + if (value == null) { + unknownFields.mergeVarintField(1, rawValue); + } else { + bitField0_ |= 0x00000001; + type_ = rawValue; + } + break; + } + case 18: { + bitField0_ |= 0x00000002; + name_ = input.readBytes(); + break; + } + case 26: { + bitField0_ |= 0x00000004; + originalName_ = input.readBytes(); + break; + } + case 34: { + bitField0_ |= 0x00000008; + table_ = input.readBytes(); + break; + } + case 42: { + bitField0_ |= 0x00000010; + originalTable_ = input.readBytes(); + break; + } + case 50: { + bitField0_ |= 0x00000020; + schema_ = input.readBytes(); + break; + } + case 58: { + bitField0_ |= 0x00000040; + catalog_ = input.readBytes(); + break; + } + case 64: { + bitField0_ |= 0x00000080; + collation_ = input.readUInt64(); + break; + } + case 72: { + bitField0_ |= 0x00000100; + fractionalDigits_ = input.readUInt32(); + break; + } + case 80: { + bitField0_ |= 0x00000200; + length_ = input.readUInt32(); + break; + } + case 88: { + bitField0_ |= 0x00000400; + flags_ = input.readUInt32(); + break; + } + case 96: { + bitField0_ |= 0x00000800; + contentType_ = input.readUInt32(); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_ColumnMetaData_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_ColumnMetaData_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData.class, com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData.Builder.class); + } + + /** + * Protobuf enum {@code Mysqlx.Resultset.ColumnMetaData.FieldType} + */ + public enum FieldType + implements com.google.protobuf.ProtocolMessageEnum { + /** + * SINT = 1; + */ + SINT(1), + /** + * UINT = 2; + */ + UINT(2), + /** + * DOUBLE = 5; + */ + DOUBLE(5), + /** + * FLOAT = 6; + */ + FLOAT(6), + /** + * BYTES = 7; + */ + BYTES(7), + /** + * TIME = 10; + */ + TIME(10), + /** + * DATETIME = 12; + */ + DATETIME(12), + /** + * SET = 15; + */ + SET(15), + /** + * ENUM = 16; + */ + ENUM(16), + /** + * BIT = 17; + */ + BIT(17), + /** + * DECIMAL = 18; + */ + DECIMAL(18), + ; + + /** + * SINT = 1; + */ + public static final int SINT_VALUE = 1; + /** + * UINT = 2; + */ + public static final int UINT_VALUE = 2; + /** + * DOUBLE = 5; + */ + public static final int DOUBLE_VALUE = 5; + /** + * FLOAT = 6; + */ + public static final int FLOAT_VALUE = 6; + /** + * BYTES = 7; + */ + public static final int BYTES_VALUE = 7; + /** + * TIME = 10; + */ + public static final int TIME_VALUE = 10; + /** + * DATETIME = 12; + */ + public static final int DATETIME_VALUE = 12; + /** + * SET = 15; + */ + public static final int SET_VALUE = 15; + /** + * ENUM = 16; + */ + public static final int ENUM_VALUE = 16; + /** + * BIT = 17; + */ + public static final int BIT_VALUE = 17; + /** + * DECIMAL = 18; + */ + public static final int DECIMAL_VALUE = 18; + + + public final int getNumber() { + return value; + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + * @deprecated Use {@link #forNumber(int)} instead. + */ + @java.lang.Deprecated + public static FieldType valueOf(int value) { + return forNumber(value); + } + + /** + * @param value The numeric wire value of the corresponding enum entry. + * @return The enum associated with the given numeric wire value. + */ + public static FieldType forNumber(int value) { + switch (value) { + case 1: return SINT; + case 2: return UINT; + case 5: return DOUBLE; + case 6: return FLOAT; + case 7: return BYTES; + case 10: return TIME; + case 12: return DATETIME; + case 15: return SET; + case 16: return ENUM; + case 17: return BIT; + case 18: return DECIMAL; + default: return null; + } + } + + public static com.google.protobuf.Internal.EnumLiteMap + internalGetValueMap() { + return internalValueMap; + } + private static final com.google.protobuf.Internal.EnumLiteMap< + FieldType> internalValueMap = + new com.google.protobuf.Internal.EnumLiteMap() { + public FieldType findValueByNumber(int number) { + return FieldType.forNumber(number); + } + }; + + public final com.google.protobuf.Descriptors.EnumValueDescriptor + getValueDescriptor() { + return getDescriptor().getValues().get(ordinal()); + } + public final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptorForType() { + return getDescriptor(); + } + public static final com.google.protobuf.Descriptors.EnumDescriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData.getDescriptor().getEnumTypes().get(0); + } + + private static final FieldType[] VALUES = values(); + + public static FieldType valueOf( + com.google.protobuf.Descriptors.EnumValueDescriptor desc) { + if (desc.getType() != getDescriptor()) { + throw new java.lang.IllegalArgumentException( + "EnumValueDescriptor is not for this type."); + } + return VALUES[desc.getIndex()]; + } + + private final int value; + + private FieldType(int value) { + this.value = value; + } + + // @@protoc_insertion_point(enum_scope:Mysqlx.Resultset.ColumnMetaData.FieldType) + } + + private int bitField0_; + public static final int TYPE_FIELD_NUMBER = 1; + private int type_; + /** + * 
+     ** datatype of the field in a row 
+     *
+ * + * required .Mysqlx.Resultset.ColumnMetaData.FieldType type = 1; + * @return Whether the type field is set. + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** datatype of the field in a row 
+     *
+ * + * required .Mysqlx.Resultset.ColumnMetaData.FieldType type = 1; + * @return The type. + */ + public com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData.FieldType getType() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData.FieldType result = com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData.FieldType.valueOf(type_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData.FieldType.SINT : result; + } + + public static final int NAME_FIELD_NUMBER = 2; + private com.google.protobuf.ByteString name_; + /** + * 
+     ** ame of the column 
+     *
+ * + * optional bytes name = 2; + * @return Whether the name field is set. + */ + public boolean hasName() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** ame of the column 
+     *
+ * + * optional bytes name = 2; + * @return The name. + */ + public com.google.protobuf.ByteString getName() { + return name_; + } + + public static final int ORIGINAL_NAME_FIELD_NUMBER = 3; + private com.google.protobuf.ByteString originalName_; + /** + * 
+     ** name of the column before an alias was applied 
+     *
+ * + * optional bytes original_name = 3; + * @return Whether the originalName field is set. + */ + public boolean hasOriginalName() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+     ** name of the column before an alias was applied 
+     *
+ * + * optional bytes original_name = 3; + * @return The originalName. + */ + public com.google.protobuf.ByteString getOriginalName() { + return originalName_; + } + + public static final int TABLE_FIELD_NUMBER = 4; + private com.google.protobuf.ByteString table_; + /** + * 
+     ** name of the table the column originates from 
+     *
+ * + * optional bytes table = 4; + * @return Whether the table field is set. + */ + public boolean hasTable() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * 
+     ** name of the table the column originates from 
+     *
+ * + * optional bytes table = 4; + * @return The table. + */ + public com.google.protobuf.ByteString getTable() { + return table_; + } + + public static final int ORIGINAL_TABLE_FIELD_NUMBER = 5; + private com.google.protobuf.ByteString originalTable_; + /** + * 
+     ** name of the table the column originates from before an alias was applied 
+     *
+ * + * optional bytes original_table = 5; + * @return Whether the originalTable field is set. + */ + public boolean hasOriginalTable() { + return ((bitField0_ & 0x00000010) != 0); + } + /** + * 
+     ** name of the table the column originates from before an alias was applied 
+     *
+ * + * optional bytes original_table = 5; + * @return The originalTable. + */ + public com.google.protobuf.ByteString getOriginalTable() { + return originalTable_; + } + + public static final int SCHEMA_FIELD_NUMBER = 6; + private com.google.protobuf.ByteString schema_; + /** + * 
+     ** schema the column originates from 
+     *
+ * + * optional bytes schema = 6; + * @return Whether the schema field is set. + */ + public boolean hasSchema() { + return ((bitField0_ & 0x00000020) != 0); + } + /** + * 
+     ** schema the column originates from 
+     *
+ * + * optional bytes schema = 6; + * @return The schema. + */ + public com.google.protobuf.ByteString getSchema() { + return schema_; + } + + public static final int CATALOG_FIELD_NUMBER = 7; + private com.google.protobuf.ByteString catalog_; + /** + * 
+     ** catalog the schema originates from
+     *@note
+     *As there is current no support for catalogs in MySQL,
+     *don't expect this field to be set. In the MySQL C/S
+     *protocol the field had the value ``def`` all the time 
+     *
+ * + * optional bytes catalog = 7; + * @return Whether the catalog field is set. + */ + public boolean hasCatalog() { + return ((bitField0_ & 0x00000040) != 0); + } + /** + * 
+     ** catalog the schema originates from
+     *@note
+     *As there is current no support for catalogs in MySQL,
+     *don't expect this field to be set. In the MySQL C/S
+     *protocol the field had the value ``def`` all the time 
+     *
+ * + * optional bytes catalog = 7; + * @return The catalog. + */ + public com.google.protobuf.ByteString getCatalog() { + return catalog_; + } + + public static final int COLLATION_FIELD_NUMBER = 8; + private long collation_; + /** + * optional uint64 collation = 8; + * @return Whether the collation field is set. + */ + public boolean hasCollation() { + return ((bitField0_ & 0x00000080) != 0); + } + /** + * optional uint64 collation = 8; + * @return The collation. + */ + public long getCollation() { + return collation_; + } + + public static final int FRACTIONAL_DIGITS_FIELD_NUMBER = 9; + private int fractionalDigits_; + /** + * 
+     ** displayed factional decimal digits for floating point and
+     *fixed point numbers 
+     *
+ * + * optional uint32 fractional_digits = 9; + * @return Whether the fractionalDigits field is set. + */ + public boolean hasFractionalDigits() { + return ((bitField0_ & 0x00000100) != 0); + } + /** + * 
+     ** displayed factional decimal digits for floating point and
+     *fixed point numbers 
+     *
+ * + * optional uint32 fractional_digits = 9; + * @return The fractionalDigits. + */ + public int getFractionalDigits() { + return fractionalDigits_; + } + + public static final int LENGTH_FIELD_NUMBER = 10; + private int length_; + /** + * 
+     ** maximum count of displayable characters of .type 
+     *
+ * + * optional uint32 length = 10; + * @return Whether the length field is set. + */ + public boolean hasLength() { + return ((bitField0_ & 0x00000200) != 0); + } + /** + * 
+     ** maximum count of displayable characters of .type 
+     *
+ * + * optional uint32 length = 10; + * @return The length. + */ + public int getLength() { + return length_; + } + + public static final int FLAGS_FIELD_NUMBER = 11; + private int flags_; + /** + * 
+     ** ``.type`` specific flags
+     *| Type    | Value  | Description  |
+     *|---------|--------|--------------|
+     *| UINT    | 0x0001 | zerofill     |
+     *| DOUBLE  | 0x0001 | unsigned     |
+     *| FLOAT   | 0x0001 | unsigned     |
+     *| DECIMAL | 0x0001 | unsigned     |
+     *| BYTES   | 0x0001 | rightpad     |
+     *| Value  | Description     |
+     *|--------|-----------------|
+     *| 0x0010 | NOT\_NULL       |
+     *| 0x0020 | PRIMARY\_KEY    |
+     *| 0x0040 | UNIQUE\_KEY     |
+     *| 0x0080 | MULTIPLE\_KEY   |
+     *| 0x0100 | AUTO\_INCREMENT |
+     *default: 0 
+     *
+ * + * optional uint32 flags = 11; + * @return Whether the flags field is set. + */ + public boolean hasFlags() { + return ((bitField0_ & 0x00000400) != 0); + } + /** + * 
+     ** ``.type`` specific flags
+     *| Type    | Value  | Description  |
+     *|---------|--------|--------------|
+     *| UINT    | 0x0001 | zerofill     |
+     *| DOUBLE  | 0x0001 | unsigned     |
+     *| FLOAT   | 0x0001 | unsigned     |
+     *| DECIMAL | 0x0001 | unsigned     |
+     *| BYTES   | 0x0001 | rightpad     |
+     *| Value  | Description     |
+     *|--------|-----------------|
+     *| 0x0010 | NOT\_NULL       |
+     *| 0x0020 | PRIMARY\_KEY    |
+     *| 0x0040 | UNIQUE\_KEY     |
+     *| 0x0080 | MULTIPLE\_KEY   |
+     *| 0x0100 | AUTO\_INCREMENT |
+     *default: 0 
+     *
+ * + * optional uint32 flags = 11; + * @return The flags. + */ + public int getFlags() { + return flags_; + } + + public static final int CONTENT_TYPE_FIELD_NUMBER = 12; + private int contentType_; + /** + * 
+     ** a hint about the higher-level encoding of a BYTES field
+     *| Type   | Value  | Description             |
+     *|--------|--------|-------------------------|
+     *| BYTES  | 0x0001 | GEOMETRY (WKB encoding) |
+     *| BYTES  | 0x0002 | JSON (text encoding)    |
+     *| BYTES  | 0x0003 | XML (text encoding)     |
+     *@note
+     *This list isn't comprehensive. As guideline: the field's
+     *value is expected to pass a validator check on client
+     *and server if this field is set. If the server adds more
+     *internal data types that rely on BLOB storage like image
+     *manipulation, seeking into complex types in BLOBs, and
+     *more types will be added 
+     *
+ * + * optional uint32 content_type = 12; + * @return Whether the contentType field is set. + */ + public boolean hasContentType() { + return ((bitField0_ & 0x00000800) != 0); + } + /** + * 
+     ** a hint about the higher-level encoding of a BYTES field
+     *| Type   | Value  | Description             |
+     *|--------|--------|-------------------------|
+     *| BYTES  | 0x0001 | GEOMETRY (WKB encoding) |
+     *| BYTES  | 0x0002 | JSON (text encoding)    |
+     *| BYTES  | 0x0003 | XML (text encoding)     |
+     *@note
+     *This list isn't comprehensive. As guideline: the field's
+     *value is expected to pass a validator check on client
+     *and server if this field is set. If the server adds more
+     *internal data types that rely on BLOB storage like image
+     *manipulation, seeking into complex types in BLOBs, and
+     *more types will be added 
+     *
+ * + * optional uint32 content_type = 12; + * @return The contentType. + */ + public int getContentType() { + return contentType_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasType()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeEnum(1, type_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeBytes(2, name_); + } + if (((bitField0_ & 0x00000004) != 0)) { + output.writeBytes(3, originalName_); + } + if (((bitField0_ & 0x00000008) != 0)) { + output.writeBytes(4, table_); + } + if (((bitField0_ & 0x00000010) != 0)) { + output.writeBytes(5, originalTable_); + } + if (((bitField0_ & 0x00000020) != 0)) { + output.writeBytes(6, schema_); + } + if (((bitField0_ & 0x00000040) != 0)) { + output.writeBytes(7, catalog_); + } + if (((bitField0_ & 0x00000080) != 0)) { + output.writeUInt64(8, collation_); + } + if (((bitField0_ & 0x00000100) != 0)) { + output.writeUInt32(9, fractionalDigits_); + } + if (((bitField0_ & 0x00000200) != 0)) { + output.writeUInt32(10, length_); + } + if (((bitField0_ & 0x00000400) != 0)) { + output.writeUInt32(11, flags_); + } + if (((bitField0_ & 0x00000800) != 0)) { + output.writeUInt32(12, contentType_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeEnumSize(1, type_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, name_); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(3, originalName_); + } + if (((bitField0_ & 0x00000008) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(4, table_); + } + if (((bitField0_ & 0x00000010) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(5, originalTable_); + } + if (((bitField0_ & 0x00000020) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(6, schema_); + } + if (((bitField0_ & 0x00000040) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(7, catalog_); + } + if (((bitField0_ & 0x00000080) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt64Size(8, collation_); + } + if (((bitField0_ & 0x00000100) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(9, fractionalDigits_); + } + if (((bitField0_ & 0x00000200) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(10, length_); + } + if (((bitField0_ & 0x00000400) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(11, flags_); + } + if (((bitField0_ & 0x00000800) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeUInt32Size(12, contentType_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData other = (com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData) obj; + + if (hasType() != other.hasType()) return false; + if (hasType()) { + if (type_ != other.type_) return false; + } + if (hasName() != other.hasName()) return false; + if (hasName()) { + if (!getName() + .equals(other.getName())) return false; + } + if (hasOriginalName() != other.hasOriginalName()) return false; + if (hasOriginalName()) { + if (!getOriginalName() + .equals(other.getOriginalName())) return false; + } + if (hasTable() != other.hasTable()) return false; + if (hasTable()) { + if (!getTable() + .equals(other.getTable())) return false; + } + if (hasOriginalTable() != other.hasOriginalTable()) return false; + if (hasOriginalTable()) { + if (!getOriginalTable() + .equals(other.getOriginalTable())) return false; + } + if (hasSchema() != other.hasSchema()) return false; + if (hasSchema()) { + if (!getSchema() + .equals(other.getSchema())) return false; + } + if (hasCatalog() != other.hasCatalog()) return false; + if (hasCatalog()) { + if (!getCatalog() + .equals(other.getCatalog())) return false; + } + if (hasCollation() != other.hasCollation()) return false; + if (hasCollation()) { + if (getCollation() + != other.getCollation()) return false; + } + if (hasFractionalDigits() != other.hasFractionalDigits()) return false; + if (hasFractionalDigits()) { + if (getFractionalDigits() + != other.getFractionalDigits()) return false; + } + if (hasLength() != other.hasLength()) return false; + if (hasLength()) { + if (getLength() + != other.getLength()) return false; + } + if (hasFlags() != other.hasFlags()) return false; + if (hasFlags()) { + if (getFlags() + != other.getFlags()) return false; + } + if (hasContentType() != other.hasContentType()) return false; + if (hasContentType()) { + if (getContentType() + != other.getContentType()) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasType()) { + hash = (37 * hash) + TYPE_FIELD_NUMBER; + hash = (53 * hash) + type_; + } + if (hasName()) { + hash = (37 * hash) + NAME_FIELD_NUMBER; + hash = (53 * hash) + getName().hashCode(); + } + if (hasOriginalName()) { + hash = (37 * hash) + ORIGINAL_NAME_FIELD_NUMBER; + hash = (53 * hash) + getOriginalName().hashCode(); + } + if (hasTable()) { + hash = (37 * hash) + TABLE_FIELD_NUMBER; + hash = (53 * hash) + getTable().hashCode(); + } + if (hasOriginalTable()) { + hash = (37 * hash) + ORIGINAL_TABLE_FIELD_NUMBER; + hash = (53 * hash) + getOriginalTable().hashCode(); + } + if (hasSchema()) { + hash = (37 * hash) + SCHEMA_FIELD_NUMBER; + hash = (53 * hash) + getSchema().hashCode(); + } + if (hasCatalog()) { + hash = (37 * hash) + CATALOG_FIELD_NUMBER; + hash = (53 * hash) + getCatalog().hashCode(); + } + if (hasCollation()) { + hash = (37 * hash) + COLLATION_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashLong( + getCollation()); + } + if (hasFractionalDigits()) { + hash = (37 * hash) + FRACTIONAL_DIGITS_FIELD_NUMBER; + hash = (53 * hash) + getFractionalDigits(); + } + if (hasLength()) { + hash = (37 * hash) + LENGTH_FIELD_NUMBER; + hash = (53 * hash) + getLength(); + } + if (hasFlags()) { + hash = (37 * hash) + FLAGS_FIELD_NUMBER; + hash = (53 * hash) + getFlags(); + } + if (hasContentType()) { + hash = (37 * hash) + CONTENT_TYPE_FIELD_NUMBER; + hash = (53 * hash) + getContentType(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Meta data of a column
+     *@note
+     *The encoding used for the different ``bytes`` fields in the
+     *meta data is externally controlled. See also:
+     *https://dev.mysql.com/doc/refman/5.0/en/charset-connection.html
+     *@par
+     *@note
+     *The server may not set the ``original_{table|name}`` fields
+     *if they are equal to the plain ``{table|name}`` field.
+     *@par
+     *@note
+     *A client has to reconstruct it like:
+     *@code{py}
+     *if .original_name is empty and .name is not empty:
+     *.original_name = .name
+     *if .original_table is empty and .table is not empty:
+     *.original_table = .table
+     *@endcode
+     *@par
+     *@note
+     *``Compact metadata format`` can be requested by the client.
+     *In that case, only ``.type`` is set and all other fields are  empty.
+     *Expected data type of Mysqlx.Resultset.Row per SQL Type for
+     *non-NULL values:
+     *| SQL Type          | .type     | .length | .frac\_dig | .flags | .charset |
+     *|-------------------|-----------|---------|------------|--------|----------|
+     *| TINY              | SINT      | x       |            |        |          |
+     *| TINY UNSIGNED     | UINT      | x       |            | x      |          |
+     *| SHORT             | SINT      | x       |            |        |          |
+     *| SHORT UNSIGNED    | UINT      | x       |            | x      |          |
+     *| INT24             | SINT      | x       |            |        |          |
+     *| INT24 UNSIGNED    | UINT      | x       |            | x      |          |
+     *| INT               | SINT      | x       |            |        |          |
+     *| INT UNSIGNED      | UINT      | x       |            | x      |          |
+     *| LONGLONG          | SINT      | x       |            |        |          |
+     *| LONGLONG UNSIGNED | UINT      | x       |            | x      |          |
+     *| DOUBLE            | DOUBLE    | x       | x          | x      |          |
+     *| FLOAT             | FLOAT     | x       | x          | x      |          |
+     *| DECIMAL           | DECIMAL   | x       | x          | x      |          |
+     *| VARCHAR,CHAR,...  | BYTES     | x       |            | x      | x        |
+     *| GEOMETRY          | BYTES     |         |            |        |          |
+     *| TIME              | TIME      | x       |            |        |          |
+     *| DATE              | DATETIME  | x       |            |        |          |
+     *| DATETIME          | DATETIME  | x       |            |        |          |
+     *| YEAR              | UINT      | x       |            | x      |          |
+     *| TIMESTAMP         | DATETIME  | x       |            |        |          |
+     *| SET               | SET       |         |            |        | x        |
+     *| ENUM              | ENUM      |         |            |        | x        |
+     *| NULL              | BYTES     |         |            |        |          |
+     *| BIT               | BIT       | x       |            |        |          |
+     *@note
+     *The SQL "NULL" value is sent as an empty field value in
+     *@ref Mysqlx::Resultset::Row.
+     *@par Tip
+     *The protobuf encoding of primitive data types is described in
+     *https://developers.google.com/protocol-buffers/docs/encoding
+     *+ SINT
+     *- ``.length`` @n
+     *Maximum number of displayable decimal digits (including
+     *minus sign) of the type.
+     *@note
+     *The valid range is 0-255, but usually you'll see 1-20.
+     *| SQL Type         | Maximum Digits per Type |
+     *|------------------|-------------------------|
+     *| TINY SIGNED      | 4                       |
+     *| SHORT SIGNED     | 6                       |
+     *| INT24 SIGNED     | 8                       |
+     *| INT SIGNED       | 11                      |
+     *| LONGLONG SIGNED  | 20                      |
+     *@par Tip
+     *Definition of ``M`` are in
+     *https://dev.mysql.com/doc/refman/5.5/en/numeric-type-overview.html.
+     *- ``value``@n
+     *Variable length encoded signed 64 integer.
+     *+ UINT
+     *- ``.flags & 1`` (zerofill) @n
+     *The client has to left pad with 0's up to .length.
+     *- ``.length`` @n
+     *Maximum number of displayable decimal digits of the
+     *type.
+     *@note
+     *The valid range is 0-255, but usually you'll see
+     *1-20.
+     *| SQL Type             | max digits per type |
+     *|----------------------|---------------------|
+     *| TINY UNSIGNED        | 3                   |
+     *| SHORT UNSIGNED       | 5                   |
+     *| INT24 UNSIGNED       | 8                   |
+     *| INT UNSIGNED         | 10                  |
+     *| LONGLONG UNSIGNED    | 20                  |
+     *@par Tip
+     *Definition of ``M`` are in
+     *https://dev.mysql.com/doc/refman/5.5/en/numeric-type-overview.html.
+     *- ``value`` @n
+     *Variable length encoded unsigned 64 integer.
+     *+ BIT
+     *- ``.length`` @n
+     *Maximum number of displayable binary digits.
+     *@note
+     *The valid range for M of the ``BIT`` type is 1 - 64.
+     *@par Tip
+     *https://dev.mysql.com/doc/refman/5.5/en/numeric-type-overview.html
+     *- ``value`` @n
+     *Variable length encoded unsigned 64 integer.
+     *+ DOUBLE
+     *- ``.length`` @n
+     *Maximum number of displayable decimal digits (including
+     *the decimal point and ``.fractional_digits``).
+     *- ``.fractional_digits`` @n
+     *Maximum number of displayable decimal digits following
+     *the decimal point.
+     *- ``value``@n
+     *Encoded as protobuf's 'double'.
+     *+ FLOAT
+     *- ``.length``@n
+     *Maximum number of displayable decimal digits (including
+     *the decimal point and ``.fractional_digits``).
+     *- ``.fractional_digits``@n
+     *Maximum number of displayable decimal digits following
+     *the decimal point.
+     *- ``value``@n
+     *Encoded as protobuf's 'float'.
+     *+ BYTES, ENUM
+     *@note
+     *BYTES is used for all opaque byte strings that may have a charset:
+     *-  TINYBLOB, BLOB, MEDIUMBLOB, LONGBLOB
+     *-  TINYTEXT, TEXT, MEDIUMTEXT, LONGTEXT
+     *-  VARCHAR, VARBINARY
+     *-  CHAR, BINARY
+     *-  ENUM
+     *- ``.length``@n
+     *Maximum length of characters of the underlying type.
+     *- ``.flags & 1`` (rightpad) @n
+     *If the length of the field is less than ``.length``, the
+     *receiver is supposed to add padding characters to the
+     *right end of the string. If the ``.charset`` is
+     *"binary", the padding character is ``0x00``, otherwise
+     *it is a space character as defined by that character
+     *set.
+     *| SQL Type      | .length  | .charset  | .flags   |
+     *|---------------|----------|-----------|----------|
+     *| TINYBLOB      | 256      | binary    |          |
+     *| BLOB          | 65535    | binary    |          |
+     *| VARCHAR(32)   | 32       | utf8      |          |
+     *| VARBINARY(32) | 32       | utf8\_bin |          |
+     *| BINARY(32)    | 32       | binary    | rightpad |
+     *| CHAR(32)      | 32       | utf8      | rightpad |
+     *- ``value``
+     *Sequence of bytes with added one extra ``0x00`` byte at
+     *the end. To obtain the original string, the extra
+     *``0x00`` should be removed. The length of the string can
+     *be acquired with protobuf's field ``length()`` method:
+     *``length of sequence-of-bytes = length-of-field - 1``
+     *@note
+     *The extra byte allows to distinguish between a NULL
+     *and empty byte sequence.
+     *+ TIME
+     *A time value.
+     *- ``value``@n
+     *The following bytes sequence:
+     *``negate [ hour [ minutes [ seconds [ useconds ]]]]``
+     *-  negate - one byte, should be one of: 0x00 for "+",
+     *0x01 for "-"
+     *-  hour - optional variable length encoded unsigned64
+     *value for the hour
+     *-  minutes - optional variable length encoded unsigned64
+     *value for the minutes
+     *-  seconds - optional variable length encoded unsigned64
+     *value for the seconds
+     *-  useconds - optional variable length encoded
+     *unsigned64 value for the microseconds
+     *@par Tip
+     *The protobuf encoding in
+     *https://developers.google.com/protocol-buffers/docs/encoding.
+     *@note
+     *Hour, minutes, seconds, and useconds are optional if
+     *all the values to the right are 0.
+     *Example: ``0x00 -> +00:00:00.000000``
+     *+ DATETIME
+     *A date or date and time value.
+     *- ``value`` @n
+     *A sequence of variants, arranged as follows:
+     *``| year | month | day | [ | hour | [ | minutes | [ | seconds | [ | useconds | ]]]]``
+     *-  year - variable length encoded unsigned64 value for
+     *the year
+     *-  month - variable length encoded unsigned64 value for
+     *the month
+     *-  day - variable length encoded unsigned64 value for
+     *the day
+     *-  hour - optional variable length encoded unsigned64
+     *value for the hour
+     *-  minutes - optional variable length encoded unsigned64
+     *value for the minutes
+     *-  seconds - optional variable length encoded unsigned64
+     *value for the seconds
+     *-  useconds - optional variable length encoded
+     *unsigned64 value for the microseconds
+     *@note
+     *Hour, minutes, seconds, useconds are optional if all
+     *the values to the right are 0.
+     *- ``.flags``@n
+     *| Name          | Position |
+     *|---------------|----------|
+     *| is\_timestamp | 1        |
+     *+ DECIMAL
+     *An arbitrary length number. The number is encoded as a
+     *single byte indicating the position of the decimal point
+     *followed by the Packed BCD encoded number. Packed BCD is
+     *used to simplify conversion to and from strings and other
+     *native arbitrary precision math data types. See also: packed
+     *BCD in https://en.wikipedia.org/wiki/Binary-coded_decimal
+     *- ``.length``
+     *Maximum number of displayable decimal digits
+     *(*excluding* the decimal point and sign, but including
+     *``.fractional_digits``).
+     *@note
+     *Should be in the range of 1 - 65.
+     *- ``.fractional_digits``
+     *The decimal digits to display out of length.
+     *@note
+     *Should be in the range of 0 - 30.
+     *``value``
+     *The following bytes sequence:
+     *``scale | BCD+ sign [0x00]?``
+     *-  scale - 8bit scale value (number of decimal digit after the '.')
+     *-  BCD - BCD encoded digits (4 bits for each digit)
+     *-  sign - sign encoded on 4 bits (0xc = "+", 0xd = "-")
+     *-  0x0 - last 4bits if length(digits) % 2 == 0
+     *Example: ``x04 0x12 0x34 0x01
+     *0xd0 -> -12.3401``
+     *+ SET
+     *A list of strings representing a SET of values.
+     *- ``value``@n
+     *A sequence of 0 or more of protobuf's bytes (length
+     *prepended octets) or one of the special sequences with a
+     *predefined meaning listed below.
+     *Example (length of the bytes array shown in brackets):
+     *-  ``[0]`` - the NULL value
+     *-  ``[1] 0x00`` - a set containing a blank string ''
+     *-  ``[1] 0x01`` - this would be an invalid value,
+     *but is to be treated as the empty set
+     *-  ``[2] 0x01 0x00`` - a set with a single item, which is the '0'
+     *character
+     *-  ``[8] 0x03 F O O 0x03 B A R`` - a set with 2 items: FOO,BAR
+     *
+ * + * Protobuf type {@code Mysqlx.Resultset.ColumnMetaData} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Resultset.ColumnMetaData) + com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaDataOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_ColumnMetaData_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_ColumnMetaData_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData.class, com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + type_ = 1; + bitField0_ = (bitField0_ & ~0x00000001); + name_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000002); + originalName_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000004); + table_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000008); + originalTable_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000010); + schema_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000020); + catalog_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000040); + collation_ = 0L; + bitField0_ = (bitField0_ & ~0x00000080); + fractionalDigits_ = 0; + bitField0_ = (bitField0_ & ~0x00000100); + length_ = 0; + bitField0_ = (bitField0_ & ~0x00000200); + flags_ = 0; + bitField0_ = (bitField0_ & ~0x00000400); + contentType_ = 0; + bitField0_ = (bitField0_ & ~0x00000800); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_ColumnMetaData_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData build() { + com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData buildPartial() { + com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData result = new com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.type_ = type_; + if (((from_bitField0_ & 0x00000002) != 0)) { + to_bitField0_ |= 0x00000002; + } + result.name_ = name_; + if (((from_bitField0_ & 0x00000004) != 0)) { + to_bitField0_ |= 0x00000004; + } + result.originalName_ = originalName_; + if (((from_bitField0_ & 0x00000008) != 0)) { + to_bitField0_ |= 0x00000008; + } + result.table_ = table_; + if (((from_bitField0_ & 0x00000010) != 0)) { + to_bitField0_ |= 0x00000010; + } + result.originalTable_ = originalTable_; + if (((from_bitField0_ & 0x00000020) != 0)) { + to_bitField0_ |= 0x00000020; + } + result.schema_ = schema_; + if (((from_bitField0_ & 0x00000040) != 0)) { + to_bitField0_ |= 0x00000040; + } + result.catalog_ = catalog_; + if (((from_bitField0_ & 0x00000080) != 0)) { + result.collation_ = collation_; + to_bitField0_ |= 0x00000080; + } + if (((from_bitField0_ & 0x00000100) != 0)) { + result.fractionalDigits_ = fractionalDigits_; + to_bitField0_ |= 0x00000100; + } + if (((from_bitField0_ & 0x00000200) != 0)) { + result.length_ = length_; + to_bitField0_ |= 0x00000200; + } + if (((from_bitField0_ & 0x00000400) != 0)) { + result.flags_ = flags_; + to_bitField0_ |= 0x00000400; + } + if (((from_bitField0_ & 0x00000800) != 0)) { + result.contentType_ = contentType_; + to_bitField0_ |= 0x00000800; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData other) { + if (other == com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData.getDefaultInstance()) return this; + if (other.hasType()) { + setType(other.getType()); + } + if (other.hasName()) { + setName(other.getName()); + } + if (other.hasOriginalName()) { + setOriginalName(other.getOriginalName()); + } + if (other.hasTable()) { + setTable(other.getTable()); + } + if (other.hasOriginalTable()) { + setOriginalTable(other.getOriginalTable()); + } + if (other.hasSchema()) { + setSchema(other.getSchema()); + } + if (other.hasCatalog()) { + setCatalog(other.getCatalog()); + } + if (other.hasCollation()) { + setCollation(other.getCollation()); + } + if (other.hasFractionalDigits()) { + setFractionalDigits(other.getFractionalDigits()); + } + if (other.hasLength()) { + setLength(other.getLength()); + } + if (other.hasFlags()) { + setFlags(other.getFlags()); + } + if (other.hasContentType()) { + setContentType(other.getContentType()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasType()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private int type_ = 1; + /** + * 
+       ** datatype of the field in a row 
+       *
+ * + * required .Mysqlx.Resultset.ColumnMetaData.FieldType type = 1; + * @return Whether the type field is set. + */ + public boolean hasType() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** datatype of the field in a row 
+       *
+ * + * required .Mysqlx.Resultset.ColumnMetaData.FieldType type = 1; + * @return The type. + */ + public com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData.FieldType getType() { + @SuppressWarnings("deprecation") + com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData.FieldType result = com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData.FieldType.valueOf(type_); + return result == null ? com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData.FieldType.SINT : result; + } + /** + * 
+       ** datatype of the field in a row 
+       *
+ * + * required .Mysqlx.Resultset.ColumnMetaData.FieldType type = 1; + * @param value The type to set. + * @return This builder for chaining. + */ + public Builder setType(com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData.FieldType value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + type_ = value.getNumber(); + onChanged(); + return this; + } + /** + * 
+       ** datatype of the field in a row 
+       *
+ * + * required .Mysqlx.Resultset.ColumnMetaData.FieldType type = 1; + * @return This builder for chaining. + */ + public Builder clearType() { + bitField0_ = (bitField0_ & ~0x00000001); + type_ = 1; + onChanged(); + return this; + } + + private com.google.protobuf.ByteString name_ = com.google.protobuf.ByteString.EMPTY; + /** + * 
+       ** ame of the column 
+       *
+ * + * optional bytes name = 2; + * @return Whether the name field is set. + */ + public boolean hasName() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** ame of the column 
+       *
+ * + * optional bytes name = 2; + * @return The name. + */ + public com.google.protobuf.ByteString getName() { + return name_; + } + /** + * 
+       ** ame of the column 
+       *
+ * + * optional bytes name = 2; + * @param value The name to set. + * @return This builder for chaining. + */ + public Builder setName(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + name_ = value; + onChanged(); + return this; + } + /** + * 
+       ** ame of the column 
+       *
+ * + * optional bytes name = 2; + * @return This builder for chaining. + */ + public Builder clearName() { + bitField0_ = (bitField0_ & ~0x00000002); + name_ = getDefaultInstance().getName(); + onChanged(); + return this; + } + + private com.google.protobuf.ByteString originalName_ = com.google.protobuf.ByteString.EMPTY; + /** + * 
+       ** name of the column before an alias was applied 
+       *
+ * + * optional bytes original_name = 3; + * @return Whether the originalName field is set. + */ + public boolean hasOriginalName() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+       ** name of the column before an alias was applied 
+       *
+ * + * optional bytes original_name = 3; + * @return The originalName. + */ + public com.google.protobuf.ByteString getOriginalName() { + return originalName_; + } + /** + * 
+       ** name of the column before an alias was applied 
+       *
+ * + * optional bytes original_name = 3; + * @param value The originalName to set. + * @return This builder for chaining. + */ + public Builder setOriginalName(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + originalName_ = value; + onChanged(); + return this; + } + /** + * 
+       ** name of the column before an alias was applied 
+       *
+ * + * optional bytes original_name = 3; + * @return This builder for chaining. + */ + public Builder clearOriginalName() { + bitField0_ = (bitField0_ & ~0x00000004); + originalName_ = getDefaultInstance().getOriginalName(); + onChanged(); + return this; + } + + private com.google.protobuf.ByteString table_ = com.google.protobuf.ByteString.EMPTY; + /** + * 
+       ** name of the table the column originates from 
+       *
+ * + * optional bytes table = 4; + * @return Whether the table field is set. + */ + public boolean hasTable() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * 
+       ** name of the table the column originates from 
+       *
+ * + * optional bytes table = 4; + * @return The table. + */ + public com.google.protobuf.ByteString getTable() { + return table_; + } + /** + * 
+       ** name of the table the column originates from 
+       *
+ * + * optional bytes table = 4; + * @param value The table to set. + * @return This builder for chaining. + */ + public Builder setTable(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000008; + table_ = value; + onChanged(); + return this; + } + /** + * 
+       ** name of the table the column originates from 
+       *
+ * + * optional bytes table = 4; + * @return This builder for chaining. + */ + public Builder clearTable() { + bitField0_ = (bitField0_ & ~0x00000008); + table_ = getDefaultInstance().getTable(); + onChanged(); + return this; + } + + private com.google.protobuf.ByteString originalTable_ = com.google.protobuf.ByteString.EMPTY; + /** + * 
+       ** name of the table the column originates from before an alias was applied 
+       *
+ * + * optional bytes original_table = 5; + * @return Whether the originalTable field is set. + */ + public boolean hasOriginalTable() { + return ((bitField0_ & 0x00000010) != 0); + } + /** + * 
+       ** name of the table the column originates from before an alias was applied 
+       *
+ * + * optional bytes original_table = 5; + * @return The originalTable. + */ + public com.google.protobuf.ByteString getOriginalTable() { + return originalTable_; + } + /** + * 
+       ** name of the table the column originates from before an alias was applied 
+       *
+ * + * optional bytes original_table = 5; + * @param value The originalTable to set. + * @return This builder for chaining. + */ + public Builder setOriginalTable(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000010; + originalTable_ = value; + onChanged(); + return this; + } + /** + * 
+       ** name of the table the column originates from before an alias was applied 
+       *
+ * + * optional bytes original_table = 5; + * @return This builder for chaining. + */ + public Builder clearOriginalTable() { + bitField0_ = (bitField0_ & ~0x00000010); + originalTable_ = getDefaultInstance().getOriginalTable(); + onChanged(); + return this; + } + + private com.google.protobuf.ByteString schema_ = com.google.protobuf.ByteString.EMPTY; + /** + * 
+       ** schema the column originates from 
+       *
+ * + * optional bytes schema = 6; + * @return Whether the schema field is set. + */ + public boolean hasSchema() { + return ((bitField0_ & 0x00000020) != 0); + } + /** + * 
+       ** schema the column originates from 
+       *
+ * + * optional bytes schema = 6; + * @return The schema. + */ + public com.google.protobuf.ByteString getSchema() { + return schema_; + } + /** + * 
+       ** schema the column originates from 
+       *
+ * + * optional bytes schema = 6; + * @param value The schema to set. + * @return This builder for chaining. + */ + public Builder setSchema(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000020; + schema_ = value; + onChanged(); + return this; + } + /** + * 
+       ** schema the column originates from 
+       *
+ * + * optional bytes schema = 6; + * @return This builder for chaining. + */ + public Builder clearSchema() { + bitField0_ = (bitField0_ & ~0x00000020); + schema_ = getDefaultInstance().getSchema(); + onChanged(); + return this; + } + + private com.google.protobuf.ByteString catalog_ = com.google.protobuf.ByteString.EMPTY; + /** + * 
+       ** catalog the schema originates from
+       *@note
+       *As there is current no support for catalogs in MySQL,
+       *don't expect this field to be set. In the MySQL C/S
+       *protocol the field had the value ``def`` all the time 
+       *
+ * + * optional bytes catalog = 7; + * @return Whether the catalog field is set. + */ + public boolean hasCatalog() { + return ((bitField0_ & 0x00000040) != 0); + } + /** + * 
+       ** catalog the schema originates from
+       *@note
+       *As there is current no support for catalogs in MySQL,
+       *don't expect this field to be set. In the MySQL C/S
+       *protocol the field had the value ``def`` all the time 
+       *
+ * + * optional bytes catalog = 7; + * @return The catalog. + */ + public com.google.protobuf.ByteString getCatalog() { + return catalog_; + } + /** + * 
+       ** catalog the schema originates from
+       *@note
+       *As there is current no support for catalogs in MySQL,
+       *don't expect this field to be set. In the MySQL C/S
+       *protocol the field had the value ``def`` all the time 
+       *
+ * + * optional bytes catalog = 7; + * @param value The catalog to set. + * @return This builder for chaining. + */ + public Builder setCatalog(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000040; + catalog_ = value; + onChanged(); + return this; + } + /** + * 
+       ** catalog the schema originates from
+       *@note
+       *As there is current no support for catalogs in MySQL,
+       *don't expect this field to be set. In the MySQL C/S
+       *protocol the field had the value ``def`` all the time 
+       *
+ * + * optional bytes catalog = 7; + * @return This builder for chaining. + */ + public Builder clearCatalog() { + bitField0_ = (bitField0_ & ~0x00000040); + catalog_ = getDefaultInstance().getCatalog(); + onChanged(); + return this; + } + + private long collation_ ; + /** + * optional uint64 collation = 8; + * @return Whether the collation field is set. + */ + public boolean hasCollation() { + return ((bitField0_ & 0x00000080) != 0); + } + /** + * optional uint64 collation = 8; + * @return The collation. + */ + public long getCollation() { + return collation_; + } + /** + * optional uint64 collation = 8; + * @param value The collation to set. + * @return This builder for chaining. + */ + public Builder setCollation(long value) { + bitField0_ |= 0x00000080; + collation_ = value; + onChanged(); + return this; + } + /** + * optional uint64 collation = 8; + * @return This builder for chaining. + */ + public Builder clearCollation() { + bitField0_ = (bitField0_ & ~0x00000080); + collation_ = 0L; + onChanged(); + return this; + } + + private int fractionalDigits_ ; + /** + * 
+       ** displayed factional decimal digits for floating point and
+       *fixed point numbers 
+       *
+ * + * optional uint32 fractional_digits = 9; + * @return Whether the fractionalDigits field is set. + */ + public boolean hasFractionalDigits() { + return ((bitField0_ & 0x00000100) != 0); + } + /** + * 
+       ** displayed factional decimal digits for floating point and
+       *fixed point numbers 
+       *
+ * + * optional uint32 fractional_digits = 9; + * @return The fractionalDigits. + */ + public int getFractionalDigits() { + return fractionalDigits_; + } + /** + * 
+       ** displayed factional decimal digits for floating point and
+       *fixed point numbers 
+       *
+ * + * optional uint32 fractional_digits = 9; + * @param value The fractionalDigits to set. + * @return This builder for chaining. + */ + public Builder setFractionalDigits(int value) { + bitField0_ |= 0x00000100; + fractionalDigits_ = value; + onChanged(); + return this; + } + /** + * 
+       ** displayed factional decimal digits for floating point and
+       *fixed point numbers 
+       *
+ * + * optional uint32 fractional_digits = 9; + * @return This builder for chaining. + */ + public Builder clearFractionalDigits() { + bitField0_ = (bitField0_ & ~0x00000100); + fractionalDigits_ = 0; + onChanged(); + return this; + } + + private int length_ ; + /** + * 
+       ** maximum count of displayable characters of .type 
+       *
+ * + * optional uint32 length = 10; + * @return Whether the length field is set. + */ + public boolean hasLength() { + return ((bitField0_ & 0x00000200) != 0); + } + /** + * 
+       ** maximum count of displayable characters of .type 
+       *
+ * + * optional uint32 length = 10; + * @return The length. + */ + public int getLength() { + return length_; + } + /** + * 
+       ** maximum count of displayable characters of .type 
+       *
+ * + * optional uint32 length = 10; + * @param value The length to set. + * @return This builder for chaining. + */ + public Builder setLength(int value) { + bitField0_ |= 0x00000200; + length_ = value; + onChanged(); + return this; + } + /** + * 
+       ** maximum count of displayable characters of .type 
+       *
+ * + * optional uint32 length = 10; + * @return This builder for chaining. + */ + public Builder clearLength() { + bitField0_ = (bitField0_ & ~0x00000200); + length_ = 0; + onChanged(); + return this; + } + + private int flags_ ; + /** + * 
+       ** ``.type`` specific flags
+       *| Type    | Value  | Description  |
+       *|---------|--------|--------------|
+       *| UINT    | 0x0001 | zerofill     |
+       *| DOUBLE  | 0x0001 | unsigned     |
+       *| FLOAT   | 0x0001 | unsigned     |
+       *| DECIMAL | 0x0001 | unsigned     |
+       *| BYTES   | 0x0001 | rightpad     |
+       *| Value  | Description     |
+       *|--------|-----------------|
+       *| 0x0010 | NOT\_NULL       |
+       *| 0x0020 | PRIMARY\_KEY    |
+       *| 0x0040 | UNIQUE\_KEY     |
+       *| 0x0080 | MULTIPLE\_KEY   |
+       *| 0x0100 | AUTO\_INCREMENT |
+       *default: 0 
+       *
+ * + * optional uint32 flags = 11; + * @return Whether the flags field is set. + */ + public boolean hasFlags() { + return ((bitField0_ & 0x00000400) != 0); + } + /** + * 
+       ** ``.type`` specific flags
+       *| Type    | Value  | Description  |
+       *|---------|--------|--------------|
+       *| UINT    | 0x0001 | zerofill     |
+       *| DOUBLE  | 0x0001 | unsigned     |
+       *| FLOAT   | 0x0001 | unsigned     |
+       *| DECIMAL | 0x0001 | unsigned     |
+       *| BYTES   | 0x0001 | rightpad     |
+       *| Value  | Description     |
+       *|--------|-----------------|
+       *| 0x0010 | NOT\_NULL       |
+       *| 0x0020 | PRIMARY\_KEY    |
+       *| 0x0040 | UNIQUE\_KEY     |
+       *| 0x0080 | MULTIPLE\_KEY   |
+       *| 0x0100 | AUTO\_INCREMENT |
+       *default: 0 
+       *
+ * + * optional uint32 flags = 11; + * @return The flags. + */ + public int getFlags() { + return flags_; + } + /** + * 
+       ** ``.type`` specific flags
+       *| Type    | Value  | Description  |
+       *|---------|--------|--------------|
+       *| UINT    | 0x0001 | zerofill     |
+       *| DOUBLE  | 0x0001 | unsigned     |
+       *| FLOAT   | 0x0001 | unsigned     |
+       *| DECIMAL | 0x0001 | unsigned     |
+       *| BYTES   | 0x0001 | rightpad     |
+       *| Value  | Description     |
+       *|--------|-----------------|
+       *| 0x0010 | NOT\_NULL       |
+       *| 0x0020 | PRIMARY\_KEY    |
+       *| 0x0040 | UNIQUE\_KEY     |
+       *| 0x0080 | MULTIPLE\_KEY   |
+       *| 0x0100 | AUTO\_INCREMENT |
+       *default: 0 
+       *
+ * + * optional uint32 flags = 11; + * @param value The flags to set. + * @return This builder for chaining. + */ + public Builder setFlags(int value) { + bitField0_ |= 0x00000400; + flags_ = value; + onChanged(); + return this; + } + /** + * 
+       ** ``.type`` specific flags
+       *| Type    | Value  | Description  |
+       *|---------|--------|--------------|
+       *| UINT    | 0x0001 | zerofill     |
+       *| DOUBLE  | 0x0001 | unsigned     |
+       *| FLOAT   | 0x0001 | unsigned     |
+       *| DECIMAL | 0x0001 | unsigned     |
+       *| BYTES   | 0x0001 | rightpad     |
+       *| Value  | Description     |
+       *|--------|-----------------|
+       *| 0x0010 | NOT\_NULL       |
+       *| 0x0020 | PRIMARY\_KEY    |
+       *| 0x0040 | UNIQUE\_KEY     |
+       *| 0x0080 | MULTIPLE\_KEY   |
+       *| 0x0100 | AUTO\_INCREMENT |
+       *default: 0 
+       *
+ * + * optional uint32 flags = 11; + * @return This builder for chaining. + */ + public Builder clearFlags() { + bitField0_ = (bitField0_ & ~0x00000400); + flags_ = 0; + onChanged(); + return this; + } + + private int contentType_ ; + /** + * 
+       ** a hint about the higher-level encoding of a BYTES field
+       *| Type   | Value  | Description             |
+       *|--------|--------|-------------------------|
+       *| BYTES  | 0x0001 | GEOMETRY (WKB encoding) |
+       *| BYTES  | 0x0002 | JSON (text encoding)    |
+       *| BYTES  | 0x0003 | XML (text encoding)     |
+       *@note
+       *This list isn't comprehensive. As guideline: the field's
+       *value is expected to pass a validator check on client
+       *and server if this field is set. If the server adds more
+       *internal data types that rely on BLOB storage like image
+       *manipulation, seeking into complex types in BLOBs, and
+       *more types will be added 
+       *
+ * + * optional uint32 content_type = 12; + * @return Whether the contentType field is set. + */ + public boolean hasContentType() { + return ((bitField0_ & 0x00000800) != 0); + } + /** + * 
+       ** a hint about the higher-level encoding of a BYTES field
+       *| Type   | Value  | Description             |
+       *|--------|--------|-------------------------|
+       *| BYTES  | 0x0001 | GEOMETRY (WKB encoding) |
+       *| BYTES  | 0x0002 | JSON (text encoding)    |
+       *| BYTES  | 0x0003 | XML (text encoding)     |
+       *@note
+       *This list isn't comprehensive. As guideline: the field's
+       *value is expected to pass a validator check on client
+       *and server if this field is set. If the server adds more
+       *internal data types that rely on BLOB storage like image
+       *manipulation, seeking into complex types in BLOBs, and
+       *more types will be added 
+       *
+ * + * optional uint32 content_type = 12; + * @return The contentType. + */ + public int getContentType() { + return contentType_; + } + /** + * 
+       ** a hint about the higher-level encoding of a BYTES field
+       *| Type   | Value  | Description             |
+       *|--------|--------|-------------------------|
+       *| BYTES  | 0x0001 | GEOMETRY (WKB encoding) |
+       *| BYTES  | 0x0002 | JSON (text encoding)    |
+       *| BYTES  | 0x0003 | XML (text encoding)     |
+       *@note
+       *This list isn't comprehensive. As guideline: the field's
+       *value is expected to pass a validator check on client
+       *and server if this field is set. If the server adds more
+       *internal data types that rely on BLOB storage like image
+       *manipulation, seeking into complex types in BLOBs, and
+       *more types will be added 
+       *
+ * + * optional uint32 content_type = 12; + * @param value The contentType to set. + * @return This builder for chaining. + */ + public Builder setContentType(int value) { + bitField0_ |= 0x00000800; + contentType_ = value; + onChanged(); + return this; + } + /** + * 
+       ** a hint about the higher-level encoding of a BYTES field
+       *| Type   | Value  | Description             |
+       *|--------|--------|-------------------------|
+       *| BYTES  | 0x0001 | GEOMETRY (WKB encoding) |
+       *| BYTES  | 0x0002 | JSON (text encoding)    |
+       *| BYTES  | 0x0003 | XML (text encoding)     |
+       *@note
+       *This list isn't comprehensive. As guideline: the field's
+       *value is expected to pass a validator check on client
+       *and server if this field is set. If the server adds more
+       *internal data types that rely on BLOB storage like image
+       *manipulation, seeking into complex types in BLOBs, and
+       *more types will be added 
+       *
+ * + * optional uint32 content_type = 12; + * @return This builder for chaining. + */ + public Builder clearContentType() { + bitField0_ = (bitField0_ & ~0x00000800); + contentType_ = 0; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Resultset.ColumnMetaData) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Resultset.ColumnMetaData) + private static final com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData(); + } + + public static com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public ColumnMetaData parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new ColumnMetaData(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.ColumnMetaData getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface RowOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Resultset.Row) + com.google.protobuf.MessageOrBuilder { + + /** + * repeated bytes field = 1; + * @return A list containing the field. + */ + java.util.List getFieldList(); + /** + * repeated bytes field = 1; + * @return The count of field. + */ + int getFieldCount(); + /** + * repeated bytes field = 1; + * @param index The index of the element to return. + * @return The field at the given index. + */ + com.google.protobuf.ByteString getField(int index); + } + /** + * 
+   **
+   *Row in a Resultset.
+   *A row is represented as a list of fields encoded as byte blobs.
+   *Value of each field is encoded as sequence of bytes using
+   *encoding appropriate for the type of the value given by
+   *``ColumnMetadata``, as specified in the @ref Mysqlx::Resultset::ColumnMetaData
+   *description.
+   *
+ * + * Protobuf type {@code Mysqlx.Resultset.Row} + */ + public static final class Row extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Resultset.Row) + RowOrBuilder { + private static final long serialVersionUID = 0L; + // Use Row.newBuilder() to construct. + private Row(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Row() { + field_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Row(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Row( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + if (!((mutable_bitField0_ & 0x00000001) != 0)) { + field_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000001; + } + field_.add(input.readBytes()); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000001) != 0)) { + field_ = java.util.Collections.unmodifiableList(field_); // C + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_Row_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_Row_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxResultset.Row.class, com.mysql.cj.x.protobuf.MysqlxResultset.Row.Builder.class); + } + + public static final int FIELD_FIELD_NUMBER = 1; + private java.util.List field_; + /** + * repeated bytes field = 1; + * @return A list containing the field. + */ + public java.util.List + getFieldList() { + return field_; + } + /** + * repeated bytes field = 1; + * @return The count of field. + */ + public int getFieldCount() { + return field_.size(); + } + /** + * repeated bytes field = 1; + * @param index The index of the element to return. + * @return The field at the given index. + */ + public com.google.protobuf.ByteString getField(int index) { + return field_.get(index); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + for (int i = 0; i < field_.size(); i++) { + output.writeBytes(1, field_.get(i)); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + { + int dataSize = 0; + for (int i = 0; i < field_.size(); i++) { + dataSize += com.google.protobuf.CodedOutputStream + .computeBytesSizeNoTag(field_.get(i)); + } + size += dataSize; + size += 1 * getFieldList().size(); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxResultset.Row)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxResultset.Row other = (com.mysql.cj.x.protobuf.MysqlxResultset.Row) obj; + + if (!getFieldList() + .equals(other.getFieldList())) return false; + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (getFieldCount() > 0) { + hash = (37 * hash) + FIELD_FIELD_NUMBER; + hash = (53 * hash) + getFieldList().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxResultset.Row parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.Row parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.Row parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.Row parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.Row parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.Row parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.Row parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.Row parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.Row parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.Row parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.Row parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxResultset.Row parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxResultset.Row prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Row in a Resultset.
+     *A row is represented as a list of fields encoded as byte blobs.
+     *Value of each field is encoded as sequence of bytes using
+     *encoding appropriate for the type of the value given by
+     *``ColumnMetadata``, as specified in the @ref Mysqlx::Resultset::ColumnMetaData
+     *description.
+     *
+ * + * Protobuf type {@code Mysqlx.Resultset.Row} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Resultset.Row) + com.mysql.cj.x.protobuf.MysqlxResultset.RowOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_Row_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_Row_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxResultset.Row.class, com.mysql.cj.x.protobuf.MysqlxResultset.Row.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxResultset.Row.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + field_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxResultset.internal_static_Mysqlx_Resultset_Row_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.Row getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxResultset.Row.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.Row build() { + com.mysql.cj.x.protobuf.MysqlxResultset.Row result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.Row buildPartial() { + com.mysql.cj.x.protobuf.MysqlxResultset.Row result = new com.mysql.cj.x.protobuf.MysqlxResultset.Row(this); + int from_bitField0_ = bitField0_; + if (((bitField0_ & 0x00000001) != 0)) { + field_ = java.util.Collections.unmodifiableList(field_); + bitField0_ = (bitField0_ & ~0x00000001); + } + result.field_ = field_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxResultset.Row) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxResultset.Row)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxResultset.Row other) { + if (other == com.mysql.cj.x.protobuf.MysqlxResultset.Row.getDefaultInstance()) return this; + if (!other.field_.isEmpty()) { + if (field_.isEmpty()) { + field_ = other.field_; + bitField0_ = (bitField0_ & ~0x00000001); + } else { + ensureFieldIsMutable(); + field_.addAll(other.field_); + } + onChanged(); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxResultset.Row parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxResultset.Row) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.util.List field_ = java.util.Collections.emptyList(); + private void ensureFieldIsMutable() { + if (!((bitField0_ & 0x00000001) != 0)) { + field_ = new java.util.ArrayList(field_); + bitField0_ |= 0x00000001; + } + } + /** + * repeated bytes field = 1; + * @return A list containing the field. + */ + public java.util.List + getFieldList() { + return ((bitField0_ & 0x00000001) != 0) ? + java.util.Collections.unmodifiableList(field_) : field_; + } + /** + * repeated bytes field = 1; + * @return The count of field. + */ + public int getFieldCount() { + return field_.size(); + } + /** + * repeated bytes field = 1; + * @param index The index of the element to return. + * @return The field at the given index. + */ + public com.google.protobuf.ByteString getField(int index) { + return field_.get(index); + } + /** + * repeated bytes field = 1; + * @param index The index to set the value at. + * @param value The field to set. + * @return This builder for chaining. + */ + public Builder setField( + int index, com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + ensureFieldIsMutable(); + field_.set(index, value); + onChanged(); + return this; + } + /** + * repeated bytes field = 1; + * @param value The field to add. + * @return This builder for chaining. + */ + public Builder addField(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + ensureFieldIsMutable(); + field_.add(value); + onChanged(); + return this; + } + /** + * repeated bytes field = 1; + * @param values The field to add. + * @return This builder for chaining. + */ + public Builder addAllField( + java.lang.Iterable values) { + ensureFieldIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, field_); + onChanged(); + return this; + } + /** + * repeated bytes field = 1; + * @return This builder for chaining. + */ + public Builder clearField() { + field_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000001); + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Resultset.Row) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Resultset.Row) + private static final com.mysql.cj.x.protobuf.MysqlxResultset.Row DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxResultset.Row(); + } + + public static com.mysql.cj.x.protobuf.MysqlxResultset.Row getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Row parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Row(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxResultset.Row getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Resultset_FetchDoneMoreOutParams_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Resultset_FetchDoneMoreOutParams_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Resultset_FetchDoneMoreResultsets_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Resultset_FetchDoneMoreResultsets_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Resultset_FetchDone_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Resultset_FetchDone_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Resultset_FetchSuspended_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Resultset_FetchSuspended_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Resultset_ColumnMetaData_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Resultset_ColumnMetaData_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Resultset_Row_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Resultset_Row_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\026mysqlx_resultset.proto\022\020Mysqlx.Results" + + "et\032\014mysqlx.proto\"\036\n\026FetchDoneMoreOutPara" + + "ms:\004\220\3520\022\"\037\n\027FetchDoneMoreResultsets:\004\220\3520" + + "\020\"\021\n\tFetchDone:\004\220\3520\016\"\026\n\016FetchSuspended:\004" + + "\220\3520\017\"\245\003\n\016ColumnMetaData\0228\n\004type\030\001 \002(\0162*." + + "Mysqlx.Resultset.ColumnMetaData.FieldTyp" + + "e\022\014\n\004name\030\002 \001(\014\022\025\n\roriginal_name\030\003 \001(\014\022\r" + + "\n\005table\030\004 \001(\014\022\026\n\016original_table\030\005 \001(\014\022\016\n" + + "\006schema\030\006 \001(\014\022\017\n\007catalog\030\007 \001(\014\022\021\n\tcollat" + + "ion\030\010 \001(\004\022\031\n\021fractional_digits\030\t \001(\r\022\016\n\006" + + "length\030\n \001(\r\022\r\n\005flags\030\013 \001(\r\022\024\n\014content_t" + + "ype\030\014 \001(\r\"\202\001\n\tFieldType\022\010\n\004SINT\020\001\022\010\n\004UIN" + + "T\020\002\022\n\n\006DOUBLE\020\005\022\t\n\005FLOAT\020\006\022\t\n\005BYTES\020\007\022\010\n" + + "\004TIME\020\n\022\014\n\010DATETIME\020\014\022\007\n\003SET\020\017\022\010\n\004ENUM\020\020" + + "\022\007\n\003BIT\020\021\022\013\n\007DECIMAL\020\022:\004\220\3520\014\"\032\n\003Row\022\r\n\005f" + + "ield\030\001 \003(\014:\004\220\3520\r*4\n\021ContentType_BYTES\022\014\n" + + "\010GEOMETRY\020\001\022\010\n\004JSON\020\002\022\007\n\003XML\020\003*.\n\024Conten" + + "tType_DATETIME\022\010\n\004DATE\020\001\022\014\n\010DATETIME\020\002B\031" + + "\n\027com.mysql.cj.x.protobuf" + }; + descriptor = com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + com.mysql.cj.x.protobuf.Mysqlx.getDescriptor(), + }); + internal_static_Mysqlx_Resultset_FetchDoneMoreOutParams_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_Mysqlx_Resultset_FetchDoneMoreOutParams_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Resultset_FetchDoneMoreOutParams_descriptor, + new java.lang.String[] { }); + internal_static_Mysqlx_Resultset_FetchDoneMoreResultsets_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_Mysqlx_Resultset_FetchDoneMoreResultsets_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Resultset_FetchDoneMoreResultsets_descriptor, + new java.lang.String[] { }); + internal_static_Mysqlx_Resultset_FetchDone_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_Mysqlx_Resultset_FetchDone_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Resultset_FetchDone_descriptor, + new java.lang.String[] { }); + internal_static_Mysqlx_Resultset_FetchSuspended_descriptor = + getDescriptor().getMessageTypes().get(3); + internal_static_Mysqlx_Resultset_FetchSuspended_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Resultset_FetchSuspended_descriptor, + new java.lang.String[] { }); + internal_static_Mysqlx_Resultset_ColumnMetaData_descriptor = + getDescriptor().getMessageTypes().get(4); + internal_static_Mysqlx_Resultset_ColumnMetaData_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Resultset_ColumnMetaData_descriptor, + new java.lang.String[] { "Type", "Name", "OriginalName", "Table", "OriginalTable", "Schema", "Catalog", "Collation", "FractionalDigits", "Length", "Flags", "ContentType", }); + internal_static_Mysqlx_Resultset_Row_descriptor = + getDescriptor().getMessageTypes().get(5); + internal_static_Mysqlx_Resultset_Row_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Resultset_Row_descriptor, + new java.lang.String[] { "Field", }); + com.google.protobuf.ExtensionRegistry registry = + com.google.protobuf.ExtensionRegistry.newInstance(); + registry.add(com.mysql.cj.x.protobuf.Mysqlx.serverMessageId); + com.google.protobuf.Descriptors.FileDescriptor + .internalUpdateFileDescriptor(descriptor, registry); + com.mysql.cj.x.protobuf.Mysqlx.getDescriptor(); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxSession.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxSession.java new file mode 100644 index 0000000..250ae87 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxSession.java @@ -0,0 +1,3212 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.x.protobuf; + +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: mysqlx_session.proto + +public final class MysqlxSession { + private MysqlxSession() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + public interface AuthenticateStartOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Session.AuthenticateStart) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** authentication mechanism name 
+     *
+ * + * required string mech_name = 1; + * @return Whether the mechName field is set. + */ + boolean hasMechName(); + /** + * 
+     ** authentication mechanism name 
+     *
+ * + * required string mech_name = 1; + * @return The mechName. + */ + java.lang.String getMechName(); + /** + * 
+     ** authentication mechanism name 
+     *
+ * + * required string mech_name = 1; + * @return The bytes for mechName. + */ + com.google.protobuf.ByteString + getMechNameBytes(); + + /** + * 
+     ** authentication data 
+     *
+ * + * optional bytes auth_data = 2; + * @return Whether the authData field is set. + */ + boolean hasAuthData(); + /** + * 
+     ** authentication data 
+     *
+ * + * optional bytes auth_data = 2; + * @return The authData. + */ + com.google.protobuf.ByteString getAuthData(); + + /** + * 
+     ** initial response 
+     *
+ * + * optional bytes initial_response = 3; + * @return Whether the initialResponse field is set. + */ + boolean hasInitialResponse(); + /** + * 
+     ** initial response 
+     *
+ * + * optional bytes initial_response = 3; + * @return The initialResponse. + */ + com.google.protobuf.ByteString getInitialResponse(); + } + /** + * 
+   **
+   *The initial message send from the client to the server to start
+   *the authentication process.
+   *@returns @ref Mysqlx::Session::AuthenticateContinue
+   *
+ * + * Protobuf type {@code Mysqlx.Session.AuthenticateStart} + */ + public static final class AuthenticateStart extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Session.AuthenticateStart) + AuthenticateStartOrBuilder { + private static final long serialVersionUID = 0L; + // Use AuthenticateStart.newBuilder() to construct. + private AuthenticateStart(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private AuthenticateStart() { + mechName_ = ""; + authData_ = com.google.protobuf.ByteString.EMPTY; + initialResponse_ = com.google.protobuf.ByteString.EMPTY; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new AuthenticateStart(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private AuthenticateStart( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000001; + mechName_ = bs; + break; + } + case 18: { + bitField0_ |= 0x00000002; + authData_ = input.readBytes(); + break; + } + case 26: { + bitField0_ |= 0x00000004; + initialResponse_ = input.readBytes(); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_AuthenticateStart_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_AuthenticateStart_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart.class, com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart.Builder.class); + } + + private int bitField0_; + public static final int MECH_NAME_FIELD_NUMBER = 1; + private volatile java.lang.Object mechName_; + /** + * 
+     ** authentication mechanism name 
+     *
+ * + * required string mech_name = 1; + * @return Whether the mechName field is set. + */ + public boolean hasMechName() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** authentication mechanism name 
+     *
+ * + * required string mech_name = 1; + * @return The mechName. + */ + public java.lang.String getMechName() { + java.lang.Object ref = mechName_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + mechName_ = s; + } + return s; + } + } + /** + * 
+     ** authentication mechanism name 
+     *
+ * + * required string mech_name = 1; + * @return The bytes for mechName. + */ + public com.google.protobuf.ByteString + getMechNameBytes() { + java.lang.Object ref = mechName_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + mechName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int AUTH_DATA_FIELD_NUMBER = 2; + private com.google.protobuf.ByteString authData_; + /** + * 
+     ** authentication data 
+     *
+ * + * optional bytes auth_data = 2; + * @return Whether the authData field is set. + */ + public boolean hasAuthData() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** authentication data 
+     *
+ * + * optional bytes auth_data = 2; + * @return The authData. + */ + public com.google.protobuf.ByteString getAuthData() { + return authData_; + } + + public static final int INITIAL_RESPONSE_FIELD_NUMBER = 3; + private com.google.protobuf.ByteString initialResponse_; + /** + * 
+     ** initial response 
+     *
+ * + * optional bytes initial_response = 3; + * @return Whether the initialResponse field is set. + */ + public boolean hasInitialResponse() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+     ** initial response 
+     *
+ * + * optional bytes initial_response = 3; + * @return The initialResponse. + */ + public com.google.protobuf.ByteString getInitialResponse() { + return initialResponse_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasMechName()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 1, mechName_); + } + if (((bitField0_ & 0x00000002) != 0)) { + output.writeBytes(2, authData_); + } + if (((bitField0_ & 0x00000004) != 0)) { + output.writeBytes(3, initialResponse_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(1, mechName_); + } + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(2, authData_); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(3, initialResponse_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart other = (com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart) obj; + + if (hasMechName() != other.hasMechName()) return false; + if (hasMechName()) { + if (!getMechName() + .equals(other.getMechName())) return false; + } + if (hasAuthData() != other.hasAuthData()) return false; + if (hasAuthData()) { + if (!getAuthData() + .equals(other.getAuthData())) return false; + } + if (hasInitialResponse() != other.hasInitialResponse()) return false; + if (hasInitialResponse()) { + if (!getInitialResponse() + .equals(other.getInitialResponse())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasMechName()) { + hash = (37 * hash) + MECH_NAME_FIELD_NUMBER; + hash = (53 * hash) + getMechName().hashCode(); + } + if (hasAuthData()) { + hash = (37 * hash) + AUTH_DATA_FIELD_NUMBER; + hash = (53 * hash) + getAuthData().hashCode(); + } + if (hasInitialResponse()) { + hash = (37 * hash) + INITIAL_RESPONSE_FIELD_NUMBER; + hash = (53 * hash) + getInitialResponse().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *The initial message send from the client to the server to start
+     *the authentication process.
+     *@returns @ref Mysqlx::Session::AuthenticateContinue
+     *
+ * + * Protobuf type {@code Mysqlx.Session.AuthenticateStart} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Session.AuthenticateStart) + com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStartOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_AuthenticateStart_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_AuthenticateStart_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart.class, com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + mechName_ = ""; + bitField0_ = (bitField0_ & ~0x00000001); + authData_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000002); + initialResponse_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000004); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_AuthenticateStart_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart build() { + com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart buildPartial() { + com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart result = new com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.mechName_ = mechName_; + if (((from_bitField0_ & 0x00000002) != 0)) { + to_bitField0_ |= 0x00000002; + } + result.authData_ = authData_; + if (((from_bitField0_ & 0x00000004) != 0)) { + to_bitField0_ |= 0x00000004; + } + result.initialResponse_ = initialResponse_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart other) { + if (other == com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart.getDefaultInstance()) return this; + if (other.hasMechName()) { + bitField0_ |= 0x00000001; + mechName_ = other.mechName_; + onChanged(); + } + if (other.hasAuthData()) { + setAuthData(other.getAuthData()); + } + if (other.hasInitialResponse()) { + setInitialResponse(other.getInitialResponse()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasMechName()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object mechName_ = ""; + /** + * 
+       ** authentication mechanism name 
+       *
+ * + * required string mech_name = 1; + * @return Whether the mechName field is set. + */ + public boolean hasMechName() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** authentication mechanism name 
+       *
+ * + * required string mech_name = 1; + * @return The mechName. + */ + public java.lang.String getMechName() { + java.lang.Object ref = mechName_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + mechName_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * 
+       ** authentication mechanism name 
+       *
+ * + * required string mech_name = 1; + * @return The bytes for mechName. + */ + public com.google.protobuf.ByteString + getMechNameBytes() { + java.lang.Object ref = mechName_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + mechName_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * 
+       ** authentication mechanism name 
+       *
+ * + * required string mech_name = 1; + * @param value The mechName to set. + * @return This builder for chaining. + */ + public Builder setMechName( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + mechName_ = value; + onChanged(); + return this; + } + /** + * 
+       ** authentication mechanism name 
+       *
+ * + * required string mech_name = 1; + * @return This builder for chaining. + */ + public Builder clearMechName() { + bitField0_ = (bitField0_ & ~0x00000001); + mechName_ = getDefaultInstance().getMechName(); + onChanged(); + return this; + } + /** + * 
+       ** authentication mechanism name 
+       *
+ * + * required string mech_name = 1; + * @param value The bytes for mechName to set. + * @return This builder for chaining. + */ + public Builder setMechNameBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + mechName_ = value; + onChanged(); + return this; + } + + private com.google.protobuf.ByteString authData_ = com.google.protobuf.ByteString.EMPTY; + /** + * 
+       ** authentication data 
+       *
+ * + * optional bytes auth_data = 2; + * @return Whether the authData field is set. + */ + public boolean hasAuthData() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** authentication data 
+       *
+ * + * optional bytes auth_data = 2; + * @return The authData. + */ + public com.google.protobuf.ByteString getAuthData() { + return authData_; + } + /** + * 
+       ** authentication data 
+       *
+ * + * optional bytes auth_data = 2; + * @param value The authData to set. + * @return This builder for chaining. + */ + public Builder setAuthData(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + authData_ = value; + onChanged(); + return this; + } + /** + * 
+       ** authentication data 
+       *
+ * + * optional bytes auth_data = 2; + * @return This builder for chaining. + */ + public Builder clearAuthData() { + bitField0_ = (bitField0_ & ~0x00000002); + authData_ = getDefaultInstance().getAuthData(); + onChanged(); + return this; + } + + private com.google.protobuf.ByteString initialResponse_ = com.google.protobuf.ByteString.EMPTY; + /** + * 
+       ** initial response 
+       *
+ * + * optional bytes initial_response = 3; + * @return Whether the initialResponse field is set. + */ + public boolean hasInitialResponse() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+       ** initial response 
+       *
+ * + * optional bytes initial_response = 3; + * @return The initialResponse. + */ + public com.google.protobuf.ByteString getInitialResponse() { + return initialResponse_; + } + /** + * 
+       ** initial response 
+       *
+ * + * optional bytes initial_response = 3; + * @param value The initialResponse to set. + * @return This builder for chaining. + */ + public Builder setInitialResponse(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000004; + initialResponse_ = value; + onChanged(); + return this; + } + /** + * 
+       ** initial response 
+       *
+ * + * optional bytes initial_response = 3; + * @return This builder for chaining. + */ + public Builder clearInitialResponse() { + bitField0_ = (bitField0_ & ~0x00000004); + initialResponse_ = getDefaultInstance().getInitialResponse(); + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Session.AuthenticateStart) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Session.AuthenticateStart) + private static final com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart(); + } + + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public AuthenticateStart parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new AuthenticateStart(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateStart getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface AuthenticateContinueOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Session.AuthenticateContinue) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** authentication data 
+     *
+ * + * required bytes auth_data = 1; + * @return Whether the authData field is set. + */ + boolean hasAuthData(); + /** + * 
+     ** authentication data 
+     *
+ * + * required bytes auth_data = 1; + * @return The authData. + */ + com.google.protobuf.ByteString getAuthData(); + } + /** + * 
+   **
+   *Send by client or server after an @ref Mysqlx::Session::AuthenticateStart
+   *to exchange more authentication data.
+   *@returns Mysqlx::Session::AuthenticateContinue
+   *
+ * + * Protobuf type {@code Mysqlx.Session.AuthenticateContinue} + */ + public static final class AuthenticateContinue extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Session.AuthenticateContinue) + AuthenticateContinueOrBuilder { + private static final long serialVersionUID = 0L; + // Use AuthenticateContinue.newBuilder() to construct. + private AuthenticateContinue(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private AuthenticateContinue() { + authData_ = com.google.protobuf.ByteString.EMPTY; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new AuthenticateContinue(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private AuthenticateContinue( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + bitField0_ |= 0x00000001; + authData_ = input.readBytes(); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_AuthenticateContinue_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_AuthenticateContinue_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue.class, com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue.Builder.class); + } + + private int bitField0_; + public static final int AUTH_DATA_FIELD_NUMBER = 1; + private com.google.protobuf.ByteString authData_; + /** + * 
+     ** authentication data 
+     *
+ * + * required bytes auth_data = 1; + * @return Whether the authData field is set. + */ + public boolean hasAuthData() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** authentication data 
+     *
+ * + * required bytes auth_data = 1; + * @return The authData. + */ + public com.google.protobuf.ByteString getAuthData() { + return authData_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasAuthData()) { + memoizedIsInitialized = 0; + return false; + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeBytes(1, authData_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, authData_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue other = (com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue) obj; + + if (hasAuthData() != other.hasAuthData()) return false; + if (hasAuthData()) { + if (!getAuthData() + .equals(other.getAuthData())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasAuthData()) { + hash = (37 * hash) + AUTH_DATA_FIELD_NUMBER; + hash = (53 * hash) + getAuthData().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Send by client or server after an @ref Mysqlx::Session::AuthenticateStart
+     *to exchange more authentication data.
+     *@returns Mysqlx::Session::AuthenticateContinue
+     *
+ * + * Protobuf type {@code Mysqlx.Session.AuthenticateContinue} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Session.AuthenticateContinue) + com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinueOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_AuthenticateContinue_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_AuthenticateContinue_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue.class, com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + authData_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_AuthenticateContinue_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue build() { + com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue buildPartial() { + com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue result = new com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.authData_ = authData_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue other) { + if (other == com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue.getDefaultInstance()) return this; + if (other.hasAuthData()) { + setAuthData(other.getAuthData()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasAuthData()) { + return false; + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private com.google.protobuf.ByteString authData_ = com.google.protobuf.ByteString.EMPTY; + /** + * 
+       ** authentication data 
+       *
+ * + * required bytes auth_data = 1; + * @return Whether the authData field is set. + */ + public boolean hasAuthData() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** authentication data 
+       *
+ * + * required bytes auth_data = 1; + * @return The authData. + */ + public com.google.protobuf.ByteString getAuthData() { + return authData_; + } + /** + * 
+       ** authentication data 
+       *
+ * + * required bytes auth_data = 1; + * @param value The authData to set. + * @return This builder for chaining. + */ + public Builder setAuthData(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + authData_ = value; + onChanged(); + return this; + } + /** + * 
+       ** authentication data 
+       *
+ * + * required bytes auth_data = 1; + * @return This builder for chaining. + */ + public Builder clearAuthData() { + bitField0_ = (bitField0_ & ~0x00000001); + authData_ = getDefaultInstance().getAuthData(); + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Session.AuthenticateContinue) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Session.AuthenticateContinue) + private static final com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue(); + } + + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public AuthenticateContinue parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new AuthenticateContinue(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateContinue getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface AuthenticateOkOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Session.AuthenticateOk) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** authentication data 
+     *
+ * + * optional bytes auth_data = 1; + * @return Whether the authData field is set. + */ + boolean hasAuthData(); + /** + * 
+     ** authentication data 
+     *
+ * + * optional bytes auth_data = 1; + * @return The authData. + */ + com.google.protobuf.ByteString getAuthData(); + } + /** + * 
+   **
+   *Sent by the server after successful authentication.
+   *
+ * + * Protobuf type {@code Mysqlx.Session.AuthenticateOk} + */ + public static final class AuthenticateOk extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Session.AuthenticateOk) + AuthenticateOkOrBuilder { + private static final long serialVersionUID = 0L; + // Use AuthenticateOk.newBuilder() to construct. + private AuthenticateOk(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private AuthenticateOk() { + authData_ = com.google.protobuf.ByteString.EMPTY; + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new AuthenticateOk(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private AuthenticateOk( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + bitField0_ |= 0x00000001; + authData_ = input.readBytes(); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_AuthenticateOk_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_AuthenticateOk_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk.class, com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk.Builder.class); + } + + private int bitField0_; + public static final int AUTH_DATA_FIELD_NUMBER = 1; + private com.google.protobuf.ByteString authData_; + /** + * 
+     ** authentication data 
+     *
+ * + * optional bytes auth_data = 1; + * @return Whether the authData field is set. + */ + public boolean hasAuthData() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** authentication data 
+     *
+ * + * optional bytes auth_data = 1; + * @return The authData. + */ + public com.google.protobuf.ByteString getAuthData() { + return authData_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeBytes(1, authData_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, authData_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk other = (com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk) obj; + + if (hasAuthData() != other.hasAuthData()) return false; + if (hasAuthData()) { + if (!getAuthData() + .equals(other.getAuthData())) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasAuthData()) { + hash = (37 * hash) + AUTH_DATA_FIELD_NUMBER; + hash = (53 * hash) + getAuthData().hashCode(); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Sent by the server after successful authentication.
+     *
+ * + * Protobuf type {@code Mysqlx.Session.AuthenticateOk} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Session.AuthenticateOk) + com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOkOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_AuthenticateOk_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_AuthenticateOk_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk.class, com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + authData_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_AuthenticateOk_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk build() { + com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk buildPartial() { + com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk result = new com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.authData_ = authData_; + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk other) { + if (other == com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk.getDefaultInstance()) return this; + if (other.hasAuthData()) { + setAuthData(other.getAuthData()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private com.google.protobuf.ByteString authData_ = com.google.protobuf.ByteString.EMPTY; + /** + * 
+       ** authentication data 
+       *
+ * + * optional bytes auth_data = 1; + * @return Whether the authData field is set. + */ + public boolean hasAuthData() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** authentication data 
+       *
+ * + * optional bytes auth_data = 1; + * @return The authData. + */ + public com.google.protobuf.ByteString getAuthData() { + return authData_; + } + /** + * 
+       ** authentication data 
+       *
+ * + * optional bytes auth_data = 1; + * @param value The authData to set. + * @return This builder for chaining. + */ + public Builder setAuthData(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + authData_ = value; + onChanged(); + return this; + } + /** + * 
+       ** authentication data 
+       *
+ * + * optional bytes auth_data = 1; + * @return This builder for chaining. + */ + public Builder clearAuthData() { + bitField0_ = (bitField0_ & ~0x00000001); + authData_ = getDefaultInstance().getAuthData(); + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Session.AuthenticateOk) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Session.AuthenticateOk) + private static final com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk(); + } + + public static com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public AuthenticateOk parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new AuthenticateOk(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSession.AuthenticateOk getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface ResetOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Session.Reset) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** if is true the session will be reset, but stays authenticated; otherwise,
+     *the session will be closed and needs to be authenticated again 
+     *
+ * + * optional bool keep_open = 1 [default = false]; + * @return Whether the keepOpen field is set. + */ + boolean hasKeepOpen(); + /** + * 
+     ** if is true the session will be reset, but stays authenticated; otherwise,
+     *the session will be closed and needs to be authenticated again 
+     *
+ * + * optional bool keep_open = 1 [default = false]; + * @return The keepOpen. + */ + boolean getKeepOpen(); + } + /** + * 
+   **
+   *Reset the current session.
+   *@returns @ref Mysqlx::Ok
+   *
+ * + * Protobuf type {@code Mysqlx.Session.Reset} + */ + public static final class Reset extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Session.Reset) + ResetOrBuilder { + private static final long serialVersionUID = 0L; + // Use Reset.newBuilder() to construct. + private Reset(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Reset() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Reset(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Reset( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 8: { + bitField0_ |= 0x00000001; + keepOpen_ = input.readBool(); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_Reset_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_Reset_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxSession.Reset.class, com.mysql.cj.x.protobuf.MysqlxSession.Reset.Builder.class); + } + + private int bitField0_; + public static final int KEEP_OPEN_FIELD_NUMBER = 1; + private boolean keepOpen_; + /** + * 
+     ** if is true the session will be reset, but stays authenticated; otherwise,
+     *the session will be closed and needs to be authenticated again 
+     *
+ * + * optional bool keep_open = 1 [default = false]; + * @return Whether the keepOpen field is set. + */ + public boolean hasKeepOpen() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** if is true the session will be reset, but stays authenticated; otherwise,
+     *the session will be closed and needs to be authenticated again 
+     *
+ * + * optional bool keep_open = 1 [default = false]; + * @return The keepOpen. + */ + public boolean getKeepOpen() { + return keepOpen_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000001) != 0)) { + output.writeBool(1, keepOpen_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(1, keepOpen_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxSession.Reset)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxSession.Reset other = (com.mysql.cj.x.protobuf.MysqlxSession.Reset) obj; + + if (hasKeepOpen() != other.hasKeepOpen()) return false; + if (hasKeepOpen()) { + if (getKeepOpen() + != other.getKeepOpen()) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasKeepOpen()) { + hash = (37 * hash) + KEEP_OPEN_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getKeepOpen()); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxSession.Reset parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Reset parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Reset parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Reset parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Reset parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Reset parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Reset parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Reset parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Reset parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Reset parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Reset parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Reset parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxSession.Reset prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Reset the current session.
+     *@returns @ref Mysqlx::Ok
+     *
+ * + * Protobuf type {@code Mysqlx.Session.Reset} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Session.Reset) + com.mysql.cj.x.protobuf.MysqlxSession.ResetOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_Reset_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_Reset_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxSession.Reset.class, com.mysql.cj.x.protobuf.MysqlxSession.Reset.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxSession.Reset.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + keepOpen_ = false; + bitField0_ = (bitField0_ & ~0x00000001); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_Reset_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSession.Reset getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxSession.Reset.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSession.Reset build() { + com.mysql.cj.x.protobuf.MysqlxSession.Reset result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSession.Reset buildPartial() { + com.mysql.cj.x.protobuf.MysqlxSession.Reset result = new com.mysql.cj.x.protobuf.MysqlxSession.Reset(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + result.keepOpen_ = keepOpen_; + to_bitField0_ |= 0x00000001; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxSession.Reset) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxSession.Reset)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxSession.Reset other) { + if (other == com.mysql.cj.x.protobuf.MysqlxSession.Reset.getDefaultInstance()) return this; + if (other.hasKeepOpen()) { + setKeepOpen(other.getKeepOpen()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxSession.Reset parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxSession.Reset) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private boolean keepOpen_ ; + /** + * 
+       ** if is true the session will be reset, but stays authenticated; otherwise,
+       *the session will be closed and needs to be authenticated again 
+       *
+ * + * optional bool keep_open = 1 [default = false]; + * @return Whether the keepOpen field is set. + */ + public boolean hasKeepOpen() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** if is true the session will be reset, but stays authenticated; otherwise,
+       *the session will be closed and needs to be authenticated again 
+       *
+ * + * optional bool keep_open = 1 [default = false]; + * @return The keepOpen. + */ + public boolean getKeepOpen() { + return keepOpen_; + } + /** + * 
+       ** if is true the session will be reset, but stays authenticated; otherwise,
+       *the session will be closed and needs to be authenticated again 
+       *
+ * + * optional bool keep_open = 1 [default = false]; + * @param value The keepOpen to set. + * @return This builder for chaining. + */ + public Builder setKeepOpen(boolean value) { + bitField0_ |= 0x00000001; + keepOpen_ = value; + onChanged(); + return this; + } + /** + * 
+       ** if is true the session will be reset, but stays authenticated; otherwise,
+       *the session will be closed and needs to be authenticated again 
+       *
+ * + * optional bool keep_open = 1 [default = false]; + * @return This builder for chaining. + */ + public Builder clearKeepOpen() { + bitField0_ = (bitField0_ & ~0x00000001); + keepOpen_ = false; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Session.Reset) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Session.Reset) + private static final com.mysql.cj.x.protobuf.MysqlxSession.Reset DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxSession.Reset(); + } + + public static com.mysql.cj.x.protobuf.MysqlxSession.Reset getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Reset parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Reset(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSession.Reset getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface CloseOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Session.Close) + com.google.protobuf.MessageOrBuilder { + } + /** + * 
+   **
+   *Close the current session.
+   *@returns @ref Mysqlx::Ok
+   *
+ * + * Protobuf type {@code Mysqlx.Session.Close} + */ + public static final class Close extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Session.Close) + CloseOrBuilder { + private static final long serialVersionUID = 0L; + // Use Close.newBuilder() to construct. + private Close(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private Close() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new Close(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private Close( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_Close_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_Close_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxSession.Close.class, com.mysql.cj.x.protobuf.MysqlxSession.Close.Builder.class); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxSession.Close)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxSession.Close other = (com.mysql.cj.x.protobuf.MysqlxSession.Close) obj; + + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxSession.Close parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Close parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Close parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Close parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Close parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Close parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Close parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Close parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Close parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Close parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Close parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxSession.Close parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxSession.Close prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Close the current session.
+     *@returns @ref Mysqlx::Ok
+     *
+ * + * Protobuf type {@code Mysqlx.Session.Close} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Session.Close) + com.mysql.cj.x.protobuf.MysqlxSession.CloseOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_Close_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_Close_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxSession.Close.class, com.mysql.cj.x.protobuf.MysqlxSession.Close.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxSession.Close.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxSession.internal_static_Mysqlx_Session_Close_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSession.Close getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxSession.Close.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSession.Close build() { + com.mysql.cj.x.protobuf.MysqlxSession.Close result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSession.Close buildPartial() { + com.mysql.cj.x.protobuf.MysqlxSession.Close result = new com.mysql.cj.x.protobuf.MysqlxSession.Close(this); + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxSession.Close) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxSession.Close)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxSession.Close other) { + if (other == com.mysql.cj.x.protobuf.MysqlxSession.Close.getDefaultInstance()) return this; + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxSession.Close parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxSession.Close) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Session.Close) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Session.Close) + private static final com.mysql.cj.x.protobuf.MysqlxSession.Close DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxSession.Close(); + } + + public static com.mysql.cj.x.protobuf.MysqlxSession.Close getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public Close parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new Close(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSession.Close getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Session_AuthenticateStart_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Session_AuthenticateStart_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Session_AuthenticateContinue_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Session_AuthenticateContinue_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Session_AuthenticateOk_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Session_AuthenticateOk_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Session_Reset_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Session_Reset_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Session_Close_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Session_Close_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\024mysqlx_session.proto\022\016Mysqlx.Session\032\014" + + "mysqlx.proto\"Y\n\021AuthenticateStart\022\021\n\tmec" + + "h_name\030\001 \002(\t\022\021\n\tauth_data\030\002 \001(\014\022\030\n\020initi" + + "al_response\030\003 \001(\014:\004\210\3520\004\"3\n\024AuthenticateC" + + "ontinue\022\021\n\tauth_data\030\001 \002(\014:\010\220\3520\003\210\3520\005\")\n\016" + + "AuthenticateOk\022\021\n\tauth_data\030\001 \001(\014:\004\220\3520\004\"" + + "\'\n\005Reset\022\030\n\tkeep_open\030\001 \001(\010:\005false:\004\210\3520\006" + + "\"\r\n\005Close:\004\210\3520\007B\031\n\027com.mysql.cj.x.protob" + + "uf" + }; + descriptor = com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + com.mysql.cj.x.protobuf.Mysqlx.getDescriptor(), + }); + internal_static_Mysqlx_Session_AuthenticateStart_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_Mysqlx_Session_AuthenticateStart_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Session_AuthenticateStart_descriptor, + new java.lang.String[] { "MechName", "AuthData", "InitialResponse", }); + internal_static_Mysqlx_Session_AuthenticateContinue_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_Mysqlx_Session_AuthenticateContinue_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Session_AuthenticateContinue_descriptor, + new java.lang.String[] { "AuthData", }); + internal_static_Mysqlx_Session_AuthenticateOk_descriptor = + getDescriptor().getMessageTypes().get(2); + internal_static_Mysqlx_Session_AuthenticateOk_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Session_AuthenticateOk_descriptor, + new java.lang.String[] { "AuthData", }); + internal_static_Mysqlx_Session_Reset_descriptor = + getDescriptor().getMessageTypes().get(3); + internal_static_Mysqlx_Session_Reset_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Session_Reset_descriptor, + new java.lang.String[] { "KeepOpen", }); + internal_static_Mysqlx_Session_Close_descriptor = + getDescriptor().getMessageTypes().get(4); + internal_static_Mysqlx_Session_Close_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Session_Close_descriptor, + new java.lang.String[] { }); + com.google.protobuf.ExtensionRegistry registry = + com.google.protobuf.ExtensionRegistry.newInstance(); + registry.add(com.mysql.cj.x.protobuf.Mysqlx.clientMessageId); + registry.add(com.mysql.cj.x.protobuf.Mysqlx.serverMessageId); + com.google.protobuf.Descriptors.FileDescriptor + .internalUpdateFileDescriptor(descriptor, registry); + com.mysql.cj.x.protobuf.Mysqlx.getDescriptor(); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxSql.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxSql.java new file mode 100644 index 0000000..4fe9d91 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/MysqlxSql.java @@ -0,0 +1,1972 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.x.protobuf; + +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: mysqlx_sql.proto + +@SuppressWarnings({ "deprecation" }) +public final class MysqlxSql { + private MysqlxSql() {} + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistryLite registry) { + } + + public static void registerAllExtensions( + com.google.protobuf.ExtensionRegistry registry) { + registerAllExtensions( + (com.google.protobuf.ExtensionRegistryLite) registry); + } + public interface StmtExecuteOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Sql.StmtExecute) + com.google.protobuf.MessageOrBuilder { + + /** + * 
+     ** namespace of the statement to be executed 
+     *
+ * + * optional string namespace = 3 [default = "sql"]; + * @return Whether the namespace field is set. + */ + boolean hasNamespace(); + /** + * 
+     ** namespace of the statement to be executed 
+     *
+ * + * optional string namespace = 3 [default = "sql"]; + * @return The namespace. + */ + java.lang.String getNamespace(); + /** + * 
+     ** namespace of the statement to be executed 
+     *
+ * + * optional string namespace = 3 [default = "sql"]; + * @return The bytes for namespace. + */ + com.google.protobuf.ByteString + getNamespaceBytes(); + + /** + * 
+     ** statement that shall be executed  
+     *
+ * + * required bytes stmt = 1; + * @return Whether the stmt field is set. + */ + boolean hasStmt(); + /** + * 
+     ** statement that shall be executed  
+     *
+ * + * required bytes stmt = 1; + * @return The stmt. + */ + com.google.protobuf.ByteString getStmt(); + + /** + * 
+     ** values for wildcard replacements 
+     *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + java.util.List + getArgsList(); + /** + * 
+     ** values for wildcard replacements 
+     *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any getArgs(int index); + /** + * 
+     ** values for wildcard replacements 
+     *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + int getArgsCount(); + /** + * 
+     ** values for wildcard replacements 
+     *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + java.util.List + getArgsOrBuilderList(); + /** + * 
+     ** values for wildcard replacements 
+     *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder getArgsOrBuilder( + int index); + + /** + * 
+     ** send only type information for @ref Mysqlx::Resultset::ColumnMetaData,
+     *skipping names and others 
+     *
+ * + * optional bool compact_metadata = 4 [default = false]; + * @return Whether the compactMetadata field is set. + */ + boolean hasCompactMetadata(); + /** + * 
+     ** send only type information for @ref Mysqlx::Resultset::ColumnMetaData,
+     *skipping names and others 
+     *
+ * + * optional bool compact_metadata = 4 [default = false]; + * @return The compactMetadata. + */ + boolean getCompactMetadata(); + } + /** + * 
+   *Execute a statement in the given namespace.
+   *@startuml "Execute Statements"
+   *client -> server: StmtExecute
+   *... zero or more Resultsets ...
+   *server --> client: StmtExecuteOk
+   *@enduml
+   *@notice This message may generate a notice containing WARNINGs generated by
+   *its execution. This message may generate a  notice containing INFO messages
+   *generated by its execution.
+   *@returns zero or more  @ref Mysqlx::Resultset followed by @ref Mysqlx::Sql::StmtExecuteOk
+   *
+ * + * Protobuf type {@code Mysqlx.Sql.StmtExecute} + */ + public static final class StmtExecute extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Sql.StmtExecute) + StmtExecuteOrBuilder { + private static final long serialVersionUID = 0L; + // Use StmtExecute.newBuilder() to construct. + private StmtExecute(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private StmtExecute() { + namespace_ = "sql"; + stmt_ = com.google.protobuf.ByteString.EMPTY; + args_ = java.util.Collections.emptyList(); + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new StmtExecute(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private StmtExecute( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + int mutable_bitField0_ = 0; + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + case 10: { + bitField0_ |= 0x00000002; + stmt_ = input.readBytes(); + break; + } + case 18: { + if (!((mutable_bitField0_ & 0x00000004) != 0)) { + args_ = new java.util.ArrayList(); + mutable_bitField0_ |= 0x00000004; + } + args_.add( + input.readMessage(com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.PARSER, extensionRegistry)); + break; + } + case 26: { + com.google.protobuf.ByteString bs = input.readBytes(); + bitField0_ |= 0x00000001; + namespace_ = bs; + break; + } + case 32: { + bitField0_ |= 0x00000004; + compactMetadata_ = input.readBool(); + break; + } + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + if (((mutable_bitField0_ & 0x00000004) != 0)) { + args_ = java.util.Collections.unmodifiableList(args_); + } + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxSql.internal_static_Mysqlx_Sql_StmtExecute_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxSql.internal_static_Mysqlx_Sql_StmtExecute_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute.class, com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute.Builder.class); + } + + private int bitField0_; + public static final int NAMESPACE_FIELD_NUMBER = 3; + private volatile java.lang.Object namespace_; + /** + * 
+     ** namespace of the statement to be executed 
+     *
+ * + * optional string namespace = 3 [default = "sql"]; + * @return Whether the namespace field is set. + */ + public boolean hasNamespace() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+     ** namespace of the statement to be executed 
+     *
+ * + * optional string namespace = 3 [default = "sql"]; + * @return The namespace. + */ + public java.lang.String getNamespace() { + java.lang.Object ref = namespace_; + if (ref instanceof java.lang.String) { + return (java.lang.String) ref; + } else { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + namespace_ = s; + } + return s; + } + } + /** + * 
+     ** namespace of the statement to be executed 
+     *
+ * + * optional string namespace = 3 [default = "sql"]; + * @return The bytes for namespace. + */ + public com.google.protobuf.ByteString + getNamespaceBytes() { + java.lang.Object ref = namespace_; + if (ref instanceof java.lang.String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + namespace_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + + public static final int STMT_FIELD_NUMBER = 1; + private com.google.protobuf.ByteString stmt_; + /** + * 
+     ** statement that shall be executed  
+     *
+ * + * required bytes stmt = 1; + * @return Whether the stmt field is set. + */ + public boolean hasStmt() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+     ** statement that shall be executed  
+     *
+ * + * required bytes stmt = 1; + * @return The stmt. + */ + public com.google.protobuf.ByteString getStmt() { + return stmt_; + } + + public static final int ARGS_FIELD_NUMBER = 2; + private java.util.List args_; + /** + * 
+     ** values for wildcard replacements 
+     *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public java.util.List getArgsList() { + return args_; + } + /** + * 
+     ** values for wildcard replacements 
+     *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public java.util.List + getArgsOrBuilderList() { + return args_; + } + /** + * 
+     ** values for wildcard replacements 
+     *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public int getArgsCount() { + return args_.size(); + } + /** + * 
+     ** values for wildcard replacements 
+     *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any getArgs(int index) { + return args_.get(index); + } + /** + * 
+     ** values for wildcard replacements 
+     *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder getArgsOrBuilder( + int index) { + return args_.get(index); + } + + public static final int COMPACT_METADATA_FIELD_NUMBER = 4; + private boolean compactMetadata_; + /** + * 
+     ** send only type information for @ref Mysqlx::Resultset::ColumnMetaData,
+     *skipping names and others 
+     *
+ * + * optional bool compact_metadata = 4 [default = false]; + * @return Whether the compactMetadata field is set. + */ + public boolean hasCompactMetadata() { + return ((bitField0_ & 0x00000004) != 0); + } + /** + * 
+     ** send only type information for @ref Mysqlx::Resultset::ColumnMetaData,
+     *skipping names and others 
+     *
+ * + * optional bool compact_metadata = 4 [default = false]; + * @return The compactMetadata. + */ + public boolean getCompactMetadata() { + return compactMetadata_; + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + if (!hasStmt()) { + memoizedIsInitialized = 0; + return false; + } + for (int i = 0; i < getArgsCount(); i++) { + if (!getArgs(i).isInitialized()) { + memoizedIsInitialized = 0; + return false; + } + } + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + if (((bitField0_ & 0x00000002) != 0)) { + output.writeBytes(1, stmt_); + } + for (int i = 0; i < args_.size(); i++) { + output.writeMessage(2, args_.get(i)); + } + if (((bitField0_ & 0x00000001) != 0)) { + com.google.protobuf.GeneratedMessageV3.writeString(output, 3, namespace_); + } + if (((bitField0_ & 0x00000004) != 0)) { + output.writeBool(4, compactMetadata_); + } + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + if (((bitField0_ & 0x00000002) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBytesSize(1, stmt_); + } + for (int i = 0; i < args_.size(); i++) { + size += com.google.protobuf.CodedOutputStream + .computeMessageSize(2, args_.get(i)); + } + if (((bitField0_ & 0x00000001) != 0)) { + size += com.google.protobuf.GeneratedMessageV3.computeStringSize(3, namespace_); + } + if (((bitField0_ & 0x00000004) != 0)) { + size += com.google.protobuf.CodedOutputStream + .computeBoolSize(4, compactMetadata_); + } + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute other = (com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute) obj; + + if (hasNamespace() != other.hasNamespace()) return false; + if (hasNamespace()) { + if (!getNamespace() + .equals(other.getNamespace())) return false; + } + if (hasStmt() != other.hasStmt()) return false; + if (hasStmt()) { + if (!getStmt() + .equals(other.getStmt())) return false; + } + if (!getArgsList() + .equals(other.getArgsList())) return false; + if (hasCompactMetadata() != other.hasCompactMetadata()) return false; + if (hasCompactMetadata()) { + if (getCompactMetadata() + != other.getCompactMetadata()) return false; + } + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + if (hasNamespace()) { + hash = (37 * hash) + NAMESPACE_FIELD_NUMBER; + hash = (53 * hash) + getNamespace().hashCode(); + } + if (hasStmt()) { + hash = (37 * hash) + STMT_FIELD_NUMBER; + hash = (53 * hash) + getStmt().hashCode(); + } + if (getArgsCount() > 0) { + hash = (37 * hash) + ARGS_FIELD_NUMBER; + hash = (53 * hash) + getArgsList().hashCode(); + } + if (hasCompactMetadata()) { + hash = (37 * hash) + COMPACT_METADATA_FIELD_NUMBER; + hash = (53 * hash) + com.google.protobuf.Internal.hashBoolean( + getCompactMetadata()); + } + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     *Execute a statement in the given namespace.
+     *@startuml "Execute Statements"
+     *client -> server: StmtExecute
+     *... zero or more Resultsets ...
+     *server --> client: StmtExecuteOk
+     *@enduml
+     *@notice This message may generate a notice containing WARNINGs generated by
+     *its execution. This message may generate a  notice containing INFO messages
+     *generated by its execution.
+     *@returns zero or more  @ref Mysqlx::Resultset followed by @ref Mysqlx::Sql::StmtExecuteOk
+     *
+ * + * Protobuf type {@code Mysqlx.Sql.StmtExecute} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Sql.StmtExecute) + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxSql.internal_static_Mysqlx_Sql_StmtExecute_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxSql.internal_static_Mysqlx_Sql_StmtExecute_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute.class, com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + getArgsFieldBuilder(); + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + namespace_ = "sql"; + bitField0_ = (bitField0_ & ~0x00000001); + stmt_ = com.google.protobuf.ByteString.EMPTY; + bitField0_ = (bitField0_ & ~0x00000002); + if (argsBuilder_ == null) { + args_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + } else { + argsBuilder_.clear(); + } + compactMetadata_ = false; + bitField0_ = (bitField0_ & ~0x00000008); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxSql.internal_static_Mysqlx_Sql_StmtExecute_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute build() { + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute buildPartial() { + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute result = new com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute(this); + int from_bitField0_ = bitField0_; + int to_bitField0_ = 0; + if (((from_bitField0_ & 0x00000001) != 0)) { + to_bitField0_ |= 0x00000001; + } + result.namespace_ = namespace_; + if (((from_bitField0_ & 0x00000002) != 0)) { + to_bitField0_ |= 0x00000002; + } + result.stmt_ = stmt_; + if (argsBuilder_ == null) { + if (((bitField0_ & 0x00000004) != 0)) { + args_ = java.util.Collections.unmodifiableList(args_); + bitField0_ = (bitField0_ & ~0x00000004); + } + result.args_ = args_; + } else { + result.args_ = argsBuilder_.build(); + } + if (((from_bitField0_ & 0x00000008) != 0)) { + result.compactMetadata_ = compactMetadata_; + to_bitField0_ |= 0x00000004; + } + result.bitField0_ = to_bitField0_; + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute other) { + if (other == com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute.getDefaultInstance()) return this; + if (other.hasNamespace()) { + bitField0_ |= 0x00000001; + namespace_ = other.namespace_; + onChanged(); + } + if (other.hasStmt()) { + setStmt(other.getStmt()); + } + if (argsBuilder_ == null) { + if (!other.args_.isEmpty()) { + if (args_.isEmpty()) { + args_ = other.args_; + bitField0_ = (bitField0_ & ~0x00000004); + } else { + ensureArgsIsMutable(); + args_.addAll(other.args_); + } + onChanged(); + } + } else { + if (!other.args_.isEmpty()) { + if (argsBuilder_.isEmpty()) { + argsBuilder_.dispose(); + argsBuilder_ = null; + args_ = other.args_; + bitField0_ = (bitField0_ & ~0x00000004); + argsBuilder_ = + com.google.protobuf.GeneratedMessageV3.alwaysUseFieldBuilders ? + getArgsFieldBuilder() : null; + } else { + argsBuilder_.addAllMessages(other.args_); + } + } + } + if (other.hasCompactMetadata()) { + setCompactMetadata(other.getCompactMetadata()); + } + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + if (!hasStmt()) { + return false; + } + for (int i = 0; i < getArgsCount(); i++) { + if (!getArgs(i).isInitialized()) { + return false; + } + } + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + private int bitField0_; + + private java.lang.Object namespace_ = "sql"; + /** + * 
+       ** namespace of the statement to be executed 
+       *
+ * + * optional string namespace = 3 [default = "sql"]; + * @return Whether the namespace field is set. + */ + public boolean hasNamespace() { + return ((bitField0_ & 0x00000001) != 0); + } + /** + * 
+       ** namespace of the statement to be executed 
+       *
+ * + * optional string namespace = 3 [default = "sql"]; + * @return The namespace. + */ + public java.lang.String getNamespace() { + java.lang.Object ref = namespace_; + if (!(ref instanceof java.lang.String)) { + com.google.protobuf.ByteString bs = + (com.google.protobuf.ByteString) ref; + java.lang.String s = bs.toStringUtf8(); + if (bs.isValidUtf8()) { + namespace_ = s; + } + return s; + } else { + return (java.lang.String) ref; + } + } + /** + * 
+       ** namespace of the statement to be executed 
+       *
+ * + * optional string namespace = 3 [default = "sql"]; + * @return The bytes for namespace. + */ + public com.google.protobuf.ByteString + getNamespaceBytes() { + java.lang.Object ref = namespace_; + if (ref instanceof String) { + com.google.protobuf.ByteString b = + com.google.protobuf.ByteString.copyFromUtf8( + (java.lang.String) ref); + namespace_ = b; + return b; + } else { + return (com.google.protobuf.ByteString) ref; + } + } + /** + * 
+       ** namespace of the statement to be executed 
+       *
+ * + * optional string namespace = 3 [default = "sql"]; + * @param value The namespace to set. + * @return This builder for chaining. + */ + public Builder setNamespace( + java.lang.String value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + namespace_ = value; + onChanged(); + return this; + } + /** + * 
+       ** namespace of the statement to be executed 
+       *
+ * + * optional string namespace = 3 [default = "sql"]; + * @return This builder for chaining. + */ + public Builder clearNamespace() { + bitField0_ = (bitField0_ & ~0x00000001); + namespace_ = getDefaultInstance().getNamespace(); + onChanged(); + return this; + } + /** + * 
+       ** namespace of the statement to be executed 
+       *
+ * + * optional string namespace = 3 [default = "sql"]; + * @param value The bytes for namespace to set. + * @return This builder for chaining. + */ + public Builder setNamespaceBytes( + com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000001; + namespace_ = value; + onChanged(); + return this; + } + + private com.google.protobuf.ByteString stmt_ = com.google.protobuf.ByteString.EMPTY; + /** + * 
+       ** statement that shall be executed  
+       *
+ * + * required bytes stmt = 1; + * @return Whether the stmt field is set. + */ + public boolean hasStmt() { + return ((bitField0_ & 0x00000002) != 0); + } + /** + * 
+       ** statement that shall be executed  
+       *
+ * + * required bytes stmt = 1; + * @return The stmt. + */ + public com.google.protobuf.ByteString getStmt() { + return stmt_; + } + /** + * 
+       ** statement that shall be executed  
+       *
+ * + * required bytes stmt = 1; + * @param value The stmt to set. + * @return This builder for chaining. + */ + public Builder setStmt(com.google.protobuf.ByteString value) { + if (value == null) { + throw new NullPointerException(); + } + bitField0_ |= 0x00000002; + stmt_ = value; + onChanged(); + return this; + } + /** + * 
+       ** statement that shall be executed  
+       *
+ * + * required bytes stmt = 1; + * @return This builder for chaining. + */ + public Builder clearStmt() { + bitField0_ = (bitField0_ & ~0x00000002); + stmt_ = getDefaultInstance().getStmt(); + onChanged(); + return this; + } + + private java.util.List args_ = + java.util.Collections.emptyList(); + private void ensureArgsIsMutable() { + if (!((bitField0_ & 0x00000004) != 0)) { + args_ = new java.util.ArrayList(args_); + bitField0_ |= 0x00000004; + } + } + + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder> argsBuilder_; + + /** + * 
+       ** values for wildcard replacements 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public java.util.List getArgsList() { + if (argsBuilder_ == null) { + return java.util.Collections.unmodifiableList(args_); + } else { + return argsBuilder_.getMessageList(); + } + } + /** + * 
+       ** values for wildcard replacements 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public int getArgsCount() { + if (argsBuilder_ == null) { + return args_.size(); + } else { + return argsBuilder_.getCount(); + } + } + /** + * 
+       ** values for wildcard replacements 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any getArgs(int index) { + if (argsBuilder_ == null) { + return args_.get(index); + } else { + return argsBuilder_.getMessage(index); + } + } + /** + * 
+       ** values for wildcard replacements 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public Builder setArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any value) { + if (argsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgsIsMutable(); + args_.set(index, value); + onChanged(); + } else { + argsBuilder_.setMessage(index, value); + } + return this; + } + /** + * 
+       ** values for wildcard replacements 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public Builder setArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder builderForValue) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.set(index, builderForValue.build()); + onChanged(); + } else { + argsBuilder_.setMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** values for wildcard replacements 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public Builder addArgs(com.mysql.cj.x.protobuf.MysqlxDatatypes.Any value) { + if (argsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgsIsMutable(); + args_.add(value); + onChanged(); + } else { + argsBuilder_.addMessage(value); + } + return this; + } + /** + * 
+       ** values for wildcard replacements 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public Builder addArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any value) { + if (argsBuilder_ == null) { + if (value == null) { + throw new NullPointerException(); + } + ensureArgsIsMutable(); + args_.add(index, value); + onChanged(); + } else { + argsBuilder_.addMessage(index, value); + } + return this; + } + /** + * 
+       ** values for wildcard replacements 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public Builder addArgs( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder builderForValue) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.add(builderForValue.build()); + onChanged(); + } else { + argsBuilder_.addMessage(builderForValue.build()); + } + return this; + } + /** + * 
+       ** values for wildcard replacements 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public Builder addArgs( + int index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder builderForValue) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.add(index, builderForValue.build()); + onChanged(); + } else { + argsBuilder_.addMessage(index, builderForValue.build()); + } + return this; + } + /** + * 
+       ** values for wildcard replacements 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public Builder addAllArgs( + java.lang.Iterable values) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + com.google.protobuf.AbstractMessageLite.Builder.addAll( + values, args_); + onChanged(); + } else { + argsBuilder_.addAllMessages(values); + } + return this; + } + /** + * 
+       ** values for wildcard replacements 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public Builder clearArgs() { + if (argsBuilder_ == null) { + args_ = java.util.Collections.emptyList(); + bitField0_ = (bitField0_ & ~0x00000004); + onChanged(); + } else { + argsBuilder_.clear(); + } + return this; + } + /** + * 
+       ** values for wildcard replacements 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public Builder removeArgs(int index) { + if (argsBuilder_ == null) { + ensureArgsIsMutable(); + args_.remove(index); + onChanged(); + } else { + argsBuilder_.remove(index); + } + return this; + } + /** + * 
+       ** values for wildcard replacements 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder getArgsBuilder( + int index) { + return getArgsFieldBuilder().getBuilder(index); + } + /** + * 
+       ** values for wildcard replacements 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder getArgsOrBuilder( + int index) { + if (argsBuilder_ == null) { + return args_.get(index); } else { + return argsBuilder_.getMessageOrBuilder(index); + } + } + /** + * 
+       ** values for wildcard replacements 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public java.util.List + getArgsOrBuilderList() { + if (argsBuilder_ != null) { + return argsBuilder_.getMessageOrBuilderList(); + } else { + return java.util.Collections.unmodifiableList(args_); + } + } + /** + * 
+       ** values for wildcard replacements 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder addArgsBuilder() { + return getArgsFieldBuilder().addBuilder( + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.getDefaultInstance()); + } + /** + * 
+       ** values for wildcard replacements 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder addArgsBuilder( + int index) { + return getArgsFieldBuilder().addBuilder( + index, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.getDefaultInstance()); + } + /** + * 
+       ** values for wildcard replacements 
+       *
+ * + * repeated .Mysqlx.Datatypes.Any args = 2; + */ + public java.util.List + getArgsBuilderList() { + return getArgsFieldBuilder().getBuilderList(); + } + private com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder> + getArgsFieldBuilder() { + if (argsBuilder_ == null) { + argsBuilder_ = new com.google.protobuf.RepeatedFieldBuilderV3< + com.mysql.cj.x.protobuf.MysqlxDatatypes.Any, com.mysql.cj.x.protobuf.MysqlxDatatypes.Any.Builder, com.mysql.cj.x.protobuf.MysqlxDatatypes.AnyOrBuilder>( + args_, + ((bitField0_ & 0x00000004) != 0), + getParentForChildren(), + isClean()); + args_ = null; + } + return argsBuilder_; + } + + private boolean compactMetadata_ ; + /** + * 
+       ** send only type information for @ref Mysqlx::Resultset::ColumnMetaData,
+       *skipping names and others 
+       *
+ * + * optional bool compact_metadata = 4 [default = false]; + * @return Whether the compactMetadata field is set. + */ + public boolean hasCompactMetadata() { + return ((bitField0_ & 0x00000008) != 0); + } + /** + * 
+       ** send only type information for @ref Mysqlx::Resultset::ColumnMetaData,
+       *skipping names and others 
+       *
+ * + * optional bool compact_metadata = 4 [default = false]; + * @return The compactMetadata. + */ + public boolean getCompactMetadata() { + return compactMetadata_; + } + /** + * 
+       ** send only type information for @ref Mysqlx::Resultset::ColumnMetaData,
+       *skipping names and others 
+       *
+ * + * optional bool compact_metadata = 4 [default = false]; + * @param value The compactMetadata to set. + * @return This builder for chaining. + */ + public Builder setCompactMetadata(boolean value) { + bitField0_ |= 0x00000008; + compactMetadata_ = value; + onChanged(); + return this; + } + /** + * 
+       ** send only type information for @ref Mysqlx::Resultset::ColumnMetaData,
+       *skipping names and others 
+       *
+ * + * optional bool compact_metadata = 4 [default = false]; + * @return This builder for chaining. + */ + public Builder clearCompactMetadata() { + bitField0_ = (bitField0_ & ~0x00000008); + compactMetadata_ = false; + onChanged(); + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Sql.StmtExecute) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Sql.StmtExecute) + private static final com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute(); + } + + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public StmtExecute parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new StmtExecute(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSql.StmtExecute getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + public interface StmtExecuteOkOrBuilder extends + // @@protoc_insertion_point(interface_extends:Mysqlx.Sql.StmtExecuteOk) + com.google.protobuf.MessageOrBuilder { + } + /** + * 
+   **
+   *Statement executed successful
+   *
+ * + * Protobuf type {@code Mysqlx.Sql.StmtExecuteOk} + */ + public static final class StmtExecuteOk extends + com.google.protobuf.GeneratedMessageV3 implements + // @@protoc_insertion_point(message_implements:Mysqlx.Sql.StmtExecuteOk) + StmtExecuteOkOrBuilder { + private static final long serialVersionUID = 0L; + // Use StmtExecuteOk.newBuilder() to construct. + private StmtExecuteOk(com.google.protobuf.GeneratedMessageV3.Builder builder) { + super(builder); + } + private StmtExecuteOk() { + } + + @java.lang.Override + @SuppressWarnings({"unused"}) + protected java.lang.Object newInstance( + UnusedPrivateParameter unused) { + return new StmtExecuteOk(); + } + + @java.lang.Override + public final com.google.protobuf.UnknownFieldSet + getUnknownFields() { + return this.unknownFields; + } + private StmtExecuteOk( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + this(); + if (extensionRegistry == null) { + throw new java.lang.NullPointerException(); + } + com.google.protobuf.UnknownFieldSet.Builder unknownFields = + com.google.protobuf.UnknownFieldSet.newBuilder(); + try { + boolean done = false; + while (!done) { + int tag = input.readTag(); + switch (tag) { + case 0: + done = true; + break; + default: { + if (!parseUnknownField( + input, unknownFields, extensionRegistry, tag)) { + done = true; + } + break; + } + } + } + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + throw e.setUnfinishedMessage(this); + } catch (java.io.IOException e) { + throw new com.google.protobuf.InvalidProtocolBufferException( + e).setUnfinishedMessage(this); + } finally { + this.unknownFields = unknownFields.build(); + makeExtensionsImmutable(); + } + } + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxSql.internal_static_Mysqlx_Sql_StmtExecuteOk_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxSql.internal_static_Mysqlx_Sql_StmtExecuteOk_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk.class, com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk.Builder.class); + } + + private byte memoizedIsInitialized = -1; + @java.lang.Override + public final boolean isInitialized() { + byte isInitialized = memoizedIsInitialized; + if (isInitialized == 1) return true; + if (isInitialized == 0) return false; + + memoizedIsInitialized = 1; + return true; + } + + @java.lang.Override + public void writeTo(com.google.protobuf.CodedOutputStream output) + throws java.io.IOException { + unknownFields.writeTo(output); + } + + @java.lang.Override + public int getSerializedSize() { + int size = memoizedSize; + if (size != -1) return size; + + size = 0; + size += unknownFields.getSerializedSize(); + memoizedSize = size; + return size; + } + + @java.lang.Override + public boolean equals(final java.lang.Object obj) { + if (obj == this) { + return true; + } + if (!(obj instanceof com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk)) { + return super.equals(obj); + } + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk other = (com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk) obj; + + if (!unknownFields.equals(other.unknownFields)) return false; + return true; + } + + @java.lang.Override + public int hashCode() { + if (memoizedHashCode != 0) { + return memoizedHashCode; + } + int hash = 41; + hash = (19 * hash) + getDescriptor().hashCode(); + hash = (29 * hash) + unknownFields.hashCode(); + memoizedHashCode = hash; + return hash; + } + + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk parseFrom( + java.nio.ByteBuffer data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk parseFrom( + java.nio.ByteBuffer data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk parseFrom( + com.google.protobuf.ByteString data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk parseFrom( + com.google.protobuf.ByteString data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk parseFrom(byte[] data) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk parseFrom( + byte[] data, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return PARSER.parseFrom(data, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk parseFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk parseFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk parseDelimitedFrom(java.io.InputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk parseDelimitedFrom( + java.io.InputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseDelimitedWithIOException(PARSER, input, extensionRegistry); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk parseFrom( + com.google.protobuf.CodedInputStream input) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input); + } + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk parseFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + return com.google.protobuf.GeneratedMessageV3 + .parseWithIOException(PARSER, input, extensionRegistry); + } + + @java.lang.Override + public Builder newBuilderForType() { return newBuilder(); } + public static Builder newBuilder() { + return DEFAULT_INSTANCE.toBuilder(); + } + public static Builder newBuilder(com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk prototype) { + return DEFAULT_INSTANCE.toBuilder().mergeFrom(prototype); + } + @java.lang.Override + public Builder toBuilder() { + return this == DEFAULT_INSTANCE + ? new Builder() : new Builder().mergeFrom(this); + } + + @java.lang.Override + protected Builder newBuilderForType( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + Builder builder = new Builder(parent); + return builder; + } + /** + * 
+     **
+     *Statement executed successful
+     *
+ * + * Protobuf type {@code Mysqlx.Sql.StmtExecuteOk} + */ + public static final class Builder extends + com.google.protobuf.GeneratedMessageV3.Builder implements + // @@protoc_insertion_point(builder_implements:Mysqlx.Sql.StmtExecuteOk) + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOkOrBuilder { + public static final com.google.protobuf.Descriptors.Descriptor + getDescriptor() { + return com.mysql.cj.x.protobuf.MysqlxSql.internal_static_Mysqlx_Sql_StmtExecuteOk_descriptor; + } + + @java.lang.Override + protected com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internalGetFieldAccessorTable() { + return com.mysql.cj.x.protobuf.MysqlxSql.internal_static_Mysqlx_Sql_StmtExecuteOk_fieldAccessorTable + .ensureFieldAccessorsInitialized( + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk.class, com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk.Builder.class); + } + + // Construct using com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk.newBuilder() + private Builder() { + maybeForceBuilderInitialization(); + } + + private Builder( + com.google.protobuf.GeneratedMessageV3.BuilderParent parent) { + super(parent); + maybeForceBuilderInitialization(); + } + private void maybeForceBuilderInitialization() { + if (com.google.protobuf.GeneratedMessageV3 + .alwaysUseFieldBuilders) { + } + } + @java.lang.Override + public Builder clear() { + super.clear(); + return this; + } + + @java.lang.Override + public com.google.protobuf.Descriptors.Descriptor + getDescriptorForType() { + return com.mysql.cj.x.protobuf.MysqlxSql.internal_static_Mysqlx_Sql_StmtExecuteOk_descriptor; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk getDefaultInstanceForType() { + return com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk.getDefaultInstance(); + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk build() { + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk result = buildPartial(); + if (!result.isInitialized()) { + throw newUninitializedMessageException(result); + } + return result; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk buildPartial() { + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk result = new com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk(this); + onBuilt(); + return result; + } + + @java.lang.Override + public Builder clone() { + return super.clone(); + } + @java.lang.Override + public Builder setField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.setField(field, value); + } + @java.lang.Override + public Builder clearField( + com.google.protobuf.Descriptors.FieldDescriptor field) { + return super.clearField(field); + } + @java.lang.Override + public Builder clearOneof( + com.google.protobuf.Descriptors.OneofDescriptor oneof) { + return super.clearOneof(oneof); + } + @java.lang.Override + public Builder setRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + int index, java.lang.Object value) { + return super.setRepeatedField(field, index, value); + } + @java.lang.Override + public Builder addRepeatedField( + com.google.protobuf.Descriptors.FieldDescriptor field, + java.lang.Object value) { + return super.addRepeatedField(field, value); + } + @java.lang.Override + public Builder mergeFrom(com.google.protobuf.Message other) { + if (other instanceof com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk) { + return mergeFrom((com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk)other); + } else { + super.mergeFrom(other); + return this; + } + } + + public Builder mergeFrom(com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk other) { + if (other == com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk.getDefaultInstance()) return this; + this.mergeUnknownFields(other.unknownFields); + onChanged(); + return this; + } + + @java.lang.Override + public final boolean isInitialized() { + return true; + } + + @java.lang.Override + public Builder mergeFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws java.io.IOException { + com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk parsedMessage = null; + try { + parsedMessage = PARSER.parsePartialFrom(input, extensionRegistry); + } catch (com.google.protobuf.InvalidProtocolBufferException e) { + parsedMessage = (com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk) e.getUnfinishedMessage(); + throw e.unwrapIOException(); + } finally { + if (parsedMessage != null) { + mergeFrom(parsedMessage); + } + } + return this; + } + @java.lang.Override + public final Builder setUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.setUnknownFields(unknownFields); + } + + @java.lang.Override + public final Builder mergeUnknownFields( + final com.google.protobuf.UnknownFieldSet unknownFields) { + return super.mergeUnknownFields(unknownFields); + } + + + // @@protoc_insertion_point(builder_scope:Mysqlx.Sql.StmtExecuteOk) + } + + // @@protoc_insertion_point(class_scope:Mysqlx.Sql.StmtExecuteOk) + private static final com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk DEFAULT_INSTANCE; + static { + DEFAULT_INSTANCE = new com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk(); + } + + public static com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk getDefaultInstance() { + return DEFAULT_INSTANCE; + } + + @java.lang.Deprecated public static final com.google.protobuf.Parser + PARSER = new com.google.protobuf.AbstractParser() { + @java.lang.Override + public StmtExecuteOk parsePartialFrom( + com.google.protobuf.CodedInputStream input, + com.google.protobuf.ExtensionRegistryLite extensionRegistry) + throws com.google.protobuf.InvalidProtocolBufferException { + return new StmtExecuteOk(input, extensionRegistry); + } + }; + + public static com.google.protobuf.Parser parser() { + return PARSER; + } + + @java.lang.Override + public com.google.protobuf.Parser getParserForType() { + return PARSER; + } + + @java.lang.Override + public com.mysql.cj.x.protobuf.MysqlxSql.StmtExecuteOk getDefaultInstanceForType() { + return DEFAULT_INSTANCE; + } + + } + + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Sql_StmtExecute_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Sql_StmtExecute_fieldAccessorTable; + private static final com.google.protobuf.Descriptors.Descriptor + internal_static_Mysqlx_Sql_StmtExecuteOk_descriptor; + private static final + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable + internal_static_Mysqlx_Sql_StmtExecuteOk_fieldAccessorTable; + + public static com.google.protobuf.Descriptors.FileDescriptor + getDescriptor() { + return descriptor; + } + private static com.google.protobuf.Descriptors.FileDescriptor + descriptor; + static { + java.lang.String[] descriptorData = { + "\n\020mysqlx_sql.proto\022\nMysqlx.Sql\032\014mysqlx.p" + + "roto\032\026mysqlx_datatypes.proto\"\177\n\013StmtExec" + + "ute\022\026\n\tnamespace\030\003 \001(\t:\003sql\022\014\n\004stmt\030\001 \002(" + + "\014\022#\n\004args\030\002 \003(\0132\025.Mysqlx.Datatypes.Any\022\037" + + "\n\020compact_metadata\030\004 \001(\010:\005false:\004\210\3520\014\"\025\n" + + "\rStmtExecuteOk:\004\220\3520\021B\031\n\027com.mysql.cj.x.p" + + "rotobuf" + }; + descriptor = com.google.protobuf.Descriptors.FileDescriptor + .internalBuildGeneratedFileFrom(descriptorData, + new com.google.protobuf.Descriptors.FileDescriptor[] { + com.mysql.cj.x.protobuf.Mysqlx.getDescriptor(), + com.mysql.cj.x.protobuf.MysqlxDatatypes.getDescriptor(), + }); + internal_static_Mysqlx_Sql_StmtExecute_descriptor = + getDescriptor().getMessageTypes().get(0); + internal_static_Mysqlx_Sql_StmtExecute_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Sql_StmtExecute_descriptor, + new java.lang.String[] { "Namespace", "Stmt", "Args", "CompactMetadata", }); + internal_static_Mysqlx_Sql_StmtExecuteOk_descriptor = + getDescriptor().getMessageTypes().get(1); + internal_static_Mysqlx_Sql_StmtExecuteOk_fieldAccessorTable = new + com.google.protobuf.GeneratedMessageV3.FieldAccessorTable( + internal_static_Mysqlx_Sql_StmtExecuteOk_descriptor, + new java.lang.String[] { }); + com.google.protobuf.ExtensionRegistry registry = + com.google.protobuf.ExtensionRegistry.newInstance(); + registry.add(com.mysql.cj.x.protobuf.Mysqlx.clientMessageId); + registry.add(com.mysql.cj.x.protobuf.Mysqlx.serverMessageId); + com.google.protobuf.Descriptors.FileDescriptor + .internalUpdateFileDescriptor(descriptor, registry); + com.mysql.cj.x.protobuf.Mysqlx.getDescriptor(); + com.mysql.cj.x.protobuf.MysqlxDatatypes.getDescriptor(); + } + + // @@protoc_insertion_point(outer_class_scope) +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/package-info.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/package-info.java new file mode 100644 index 0000000..1d6234c --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/generated/java/com/mysql/cj/x/protobuf/package-info.java @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +/** + * Message classes used for serialization with Google Protocol Buffers to support the X Protocol. Classes are generated using protoc like so: + * + * 
+ * protoc --java_out=PATH/src/generated/java --proto_path=PATH_TO_IMPORTS -I=PATH_TO_MYSQL_REPO/rapid/plugin/x/protocol PATH_TO_MYSQL_REPO/rapid/plugin/x/protocol/*.proto
+ *
+ * + * @since 6.0 + */ + +package com.mysql.cj.x.protobuf; diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/legacy/java/com/mysql/jdbc/Driver.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/legacy/java/com/mysql/jdbc/Driver.java new file mode 100644 index 0000000..992504e --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/legacy/java/com/mysql/jdbc/Driver.java @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.jdbc; + +import java.sql.SQLException; + +/** + * Backwards compatibility to support apps that call Class.forName("com.mysql.jdbc.Driver");. + */ +public class Driver extends com.mysql.cj.jdbc.Driver { + public Driver() throws SQLException { + super(); + } + + static { + System.err.println("Loading class `com.mysql.jdbc.Driver'. This is deprecated. The new driver class is `com.mysql.cj.jdbc.Driver'. " + + "The driver is automatically registered via the SPI and manual loading of the driver class is generally unnecessary."); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/legacy/java/com/mysql/jdbc/SocketFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/legacy/java/com/mysql/jdbc/SocketFactory.java new file mode 100644 index 0000000..c768929 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/legacy/java/com/mysql/jdbc/SocketFactory.java @@ -0,0 +1,98 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.jdbc; + +import java.io.IOException; +import java.net.Socket; +import java.net.SocketException; +import java.util.Properties; + +/** + * Interface to allow pluggable socket creation in the driver + * + * @deprecated Use {@link com.mysql.cj.protocol.SocketFactory} instead. + */ +@Deprecated +public interface SocketFactory { + + /** + * Called by the driver after issuing the MySQL protocol handshake and + * reading the results of the handshake. + * + * @throws SocketException + * if a socket error occurs + * @throws IOException + * if an I/O error occurs + * + * @return the socket to use after the handshake + */ + Socket afterHandshake() throws SocketException, IOException; + + /** + * Called by the driver before issuing the MySQL protocol handshake. Should + * return the socket instance that should be used during the handshake. + * + * @throws SocketException + * if a socket error occurs + * @throws IOException + * if an I/O error occurs + * + * @return the socket to use before the handshake + */ + Socket beforeHandshake() throws SocketException, IOException; + + /** + * Creates a new socket using the given properties. Properties are parsed by + * the driver from the URL. All properties other than sensitive ones (user + * and password) are passed to this method. The driver will instantiate the + * socket factory with the class name given in the property + * "socketFactory", where the standard is com.mysql.jdbc.StandardSocketFactory Implementing classes + * are responsible for handling synchronization of this method (if needed). + * + * @param host + * the hostname passed in the JDBC URL. It will be a single + * hostname, as the driver parses multi-hosts (for failover) and + * calls this method for each host connection attempt. + * + * @param portNumber + * the port number to connect to (if required). + * + * @param props + * properties passed to the driver via the URL and/or properties + * instance. + * + * @return a socket connected to the given host + * @throws SocketException + * if a socket error occurs + * @throws IOException + * if an I/O error occurs + */ + Socket connect(String host, int portNumber, Properties props) throws SocketException, IOException; +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/legacy/java/com/mysql/jdbc/SocketFactoryWrapper.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/legacy/java/com/mysql/jdbc/SocketFactoryWrapper.java new file mode 100644 index 0000000..72e3d38 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/legacy/java/com/mysql/jdbc/SocketFactoryWrapper.java @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2018, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.jdbc; + +import java.io.Closeable; +import java.io.IOException; + +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.log.Log; +import com.mysql.cj.protocol.ServerSession; +import com.mysql.cj.protocol.SocketConnection; +import com.mysql.cj.protocol.SocketFactory; +import com.mysql.cj.protocol.StandardSocketFactory; + +/** + * Wraps the legacy com.mysql.jdbc.SocketFactory implementations so they can be used as {@link SocketFactory} + */ +public class SocketFactoryWrapper extends StandardSocketFactory implements SocketFactory { + + @SuppressWarnings("deprecation") + com.mysql.jdbc.SocketFactory socketFactory; + + @SuppressWarnings("deprecation") + public SocketFactoryWrapper(Object legacyFactory) { + this.socketFactory = (com.mysql.jdbc.SocketFactory) legacyFactory; + } + + @SuppressWarnings({ "deprecation", "unchecked" }) + @Override + public T connect(String hostname, int portNumber, PropertySet pset, int loginTimeout) throws IOException { + this.rawSocket = this.socketFactory.connect(hostname, portNumber, pset.exposeAsProperties()); + return (T) this.rawSocket; + } + + @SuppressWarnings("unchecked") + @Override + public T performTlsHandshake(SocketConnection socketConnection, ServerSession serverSession, Log log) throws IOException { + return (T) super.performTlsHandshake(socketConnection, serverSession, log); + } + + @SuppressWarnings("deprecation") + @Override + public void beforeHandshake() throws IOException { + this.socketFactory.beforeHandshake(); + } + + @SuppressWarnings("deprecation") + @Override + public void afterHandshake() throws IOException { + this.socketFactory.afterHandshake(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/AppendingBatchVisitor.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/AppendingBatchVisitor.java new file mode 100644 index 0000000..21c842e --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/AppendingBatchVisitor.java @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2017, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.util.LinkedList; + +import com.mysql.cj.util.StringUtils; + +public class AppendingBatchVisitor implements BatchVisitor { + LinkedList statementComponents = new LinkedList<>(); + + public BatchVisitor append(byte[] values) { + this.statementComponents.addLast(values); + + return this; + } + + public BatchVisitor increment() { + // no-op + return this; + } + + public BatchVisitor decrement() { + this.statementComponents.removeLast(); + + return this; + } + + public BatchVisitor merge(byte[] front, byte[] back) { + int mergedLength = front.length + back.length; + byte[] merged = new byte[mergedLength]; + System.arraycopy(front, 0, merged, 0, front.length); + System.arraycopy(back, 0, merged, front.length, back.length); + this.statementComponents.addLast(merged); + return this; + } + + @Override + public BatchVisitor mergeWithLast(byte[] values) { + if (this.statementComponents.isEmpty()) { + return append(values); + } + return merge(this.statementComponents.removeLast(), values); + } + + public byte[][] getStaticSqlStrings() { + byte[][] asBytes = new byte[this.statementComponents.size()][]; + this.statementComponents.toArray(asBytes); + + return asBytes; + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + for (byte[] comp : this.statementComponents) { + sb.append(StringUtils.toString(comp)); + } + return sb.toString(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/BatchVisitor.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/BatchVisitor.java new file mode 100644 index 0000000..86ae31f --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/BatchVisitor.java @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2017, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +public interface BatchVisitor { + + BatchVisitor increment(); + + BatchVisitor decrement(); + + BatchVisitor append(byte[] values); + + BatchVisitor merge(byte[] begin, byte[] end); + + BatchVisitor mergeWithLast(byte[] values); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/BindValue.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/BindValue.java new file mode 100644 index 0000000..55dedf2 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/BindValue.java @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2017, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.io.InputStream; + +public interface BindValue { + + BindValue clone(); + + void reset(); + + boolean isNull(); + + void setNull(boolean isNull); + + boolean isStream(); + + void setIsStream(boolean isStream); + + MysqlType getMysqlType(); + + void setMysqlType(MysqlType type); + + byte[] getByteValue(); + + void setByteValue(byte[] parameterValue); + + void setOrigByteValue(byte[] origParamValue); + + byte[] getOrigByteValue(); + + InputStream getStreamValue(); + + void setStreamValue(InputStream parameterStream, long streamLength); + + long getStreamLength(); + + boolean isSet(); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/CacheAdapter.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/CacheAdapter.java new file mode 100644 index 0000000..80148fc --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/CacheAdapter.java @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2012, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.util.Set; + +public interface CacheAdapter { + V get(K key); + + void put(K key, V value); + + void invalidate(K key); + + void invalidateAll(Set keys); + + void invalidateAll(); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/CacheAdapterFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/CacheAdapterFactory.java new file mode 100644 index 0000000..4604852 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/CacheAdapterFactory.java @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2012, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +public interface CacheAdapterFactory { + + CacheAdapter getInstance(Object syncMutex, String url, int cacheMaxSize, int maxKeySize); + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/CancelQueryTask.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/CancelQueryTask.java new file mode 100644 index 0000000..d8456ee --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/CancelQueryTask.java @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2018, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +public interface CancelQueryTask { + + boolean cancel(); + + Throwable getCaughtWhileCancelling(); + + void setCaughtWhileCancelling(Throwable caughtWhileCancelling); + + Query getQueryToCancel(); + + void setQueryToCancel(Query queryToCancel); + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/CharsetMapping.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/CharsetMapping.java new file mode 100644 index 0000000..8f3c7bb --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/CharsetMapping.java @@ -0,0 +1,767 @@ +/* + * Copyright (c) 2002, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.nio.charset.Charset; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.Set; +import java.util.TreeMap; + +/** + * Mapping between MySQL charset names and Java charset names. I've investigated placing these in a .properties file, but unfortunately under most appservers + * this complicates configuration because the security policy needs to be changed by the user to allow the driver to read them :( + */ +public class CharsetMapping { + + public static final int MAP_SIZE = 1024; // Size of static maps + private static final String[] COLLATION_INDEX_TO_COLLATION_NAME; + private static final Map COLLATION_INDEX_TO_CHARSET; + + private static final Map CHARSET_NAME_TO_CHARSET; + private static final Map CHARSET_NAME_TO_COLLATION_INDEX; + private static final Map COLLATION_NAME_TO_COLLATION_INDEX; + + private static final Map> JAVA_ENCODING_UC_TO_MYSQL_CHARSET; + + private static final Set MULTIBYTE_ENCODINGS; + + /** + * Indexes of collations using ucs2, utf16, utf16le or utf32 character sets and that cannot be set to character_set_client system variable. + */ + private static final Set IMPERMISSIBLE_INDEXES; + + public static final String MYSQL_CHARSET_NAME_armscii8 = "armscii8"; + public static final String MYSQL_CHARSET_NAME_ascii = "ascii"; + public static final String MYSQL_CHARSET_NAME_big5 = "big5"; + public static final String MYSQL_CHARSET_NAME_binary = "binary"; + public static final String MYSQL_CHARSET_NAME_cp1250 = "cp1250"; + public static final String MYSQL_CHARSET_NAME_cp1251 = "cp1251"; + public static final String MYSQL_CHARSET_NAME_cp1256 = "cp1256"; + public static final String MYSQL_CHARSET_NAME_cp1257 = "cp1257"; + public static final String MYSQL_CHARSET_NAME_cp850 = "cp850"; + public static final String MYSQL_CHARSET_NAME_cp852 = "cp852"; + public static final String MYSQL_CHARSET_NAME_cp866 = "cp866"; + public static final String MYSQL_CHARSET_NAME_cp932 = "cp932"; + public static final String MYSQL_CHARSET_NAME_dec8 = "dec8"; + public static final String MYSQL_CHARSET_NAME_eucjpms = "eucjpms"; + public static final String MYSQL_CHARSET_NAME_euckr = "euckr"; + public static final String MYSQL_CHARSET_NAME_gb18030 = "gb18030"; + public static final String MYSQL_CHARSET_NAME_gb2312 = "gb2312"; + public static final String MYSQL_CHARSET_NAME_gbk = "gbk"; + public static final String MYSQL_CHARSET_NAME_geostd8 = "geostd8"; + public static final String MYSQL_CHARSET_NAME_greek = "greek"; + public static final String MYSQL_CHARSET_NAME_hebrew = "hebrew"; + public static final String MYSQL_CHARSET_NAME_hp8 = "hp8"; + public static final String MYSQL_CHARSET_NAME_keybcs2 = "keybcs2"; + public static final String MYSQL_CHARSET_NAME_koi8r = "koi8r"; + public static final String MYSQL_CHARSET_NAME_koi8u = "koi8u"; + public static final String MYSQL_CHARSET_NAME_latin1 = "latin1"; + public static final String MYSQL_CHARSET_NAME_latin2 = "latin2"; + public static final String MYSQL_CHARSET_NAME_latin5 = "latin5"; + public static final String MYSQL_CHARSET_NAME_latin7 = "latin7"; + public static final String MYSQL_CHARSET_NAME_macce = "macce"; + public static final String MYSQL_CHARSET_NAME_macroman = "macroman"; + public static final String MYSQL_CHARSET_NAME_sjis = "sjis"; + public static final String MYSQL_CHARSET_NAME_swe7 = "swe7"; + public static final String MYSQL_CHARSET_NAME_tis620 = "tis620"; + public static final String MYSQL_CHARSET_NAME_ucs2 = "ucs2"; + public static final String MYSQL_CHARSET_NAME_ujis = "ujis"; + public static final String MYSQL_CHARSET_NAME_utf16 = "utf16"; + public static final String MYSQL_CHARSET_NAME_utf16le = "utf16le"; + public static final String MYSQL_CHARSET_NAME_utf32 = "utf32"; + public static final String MYSQL_CHARSET_NAME_utf8 = "utf8"; + public static final String MYSQL_CHARSET_NAME_utf8mb4 = "utf8mb4"; + + public static final int MYSQL_COLLATION_INDEX_utf8mb4_general_ci = 45; + public static final int MYSQL_COLLATION_INDEX_utf8mb4_0900_ai_ci = 255; + public static final int MYSQL_COLLATION_INDEX_binary = 63; + + static { + // complete list of mysql character sets and their corresponding java encoding names + MysqlCharset[] charset = new MysqlCharset[] { new MysqlCharset(MYSQL_CHARSET_NAME_ascii, 1, 0, new String[] { "US-ASCII", "ASCII" }), + + new MysqlCharset(MYSQL_CHARSET_NAME_big5, 2, 0, new String[] { "Big5" }), + new MysqlCharset(MYSQL_CHARSET_NAME_gbk, 2, 0, new String[] { "GBK" }), + + new MysqlCharset(MYSQL_CHARSET_NAME_sjis, 2, 0, new String[] { "SHIFT_JIS", "Cp943", "WINDOWS-31J" }), // SJIS is alias for SHIFT_JIS, Cp943 is rather a cp932 but we map it to sjis for years + new MysqlCharset(MYSQL_CHARSET_NAME_cp932, 2, 1, new String[] { "WINDOWS-31J" }), + + new MysqlCharset(MYSQL_CHARSET_NAME_gb2312, 2, 0, new String[] { "GB2312" }), + new MysqlCharset(MYSQL_CHARSET_NAME_ujis, 3, 0, new String[] { "EUC_JP" }), + new MysqlCharset(MYSQL_CHARSET_NAME_eucjpms, 3, 0, new String[] { "EUC_JP_Solaris" }, new ServerVersion(5, 0, 3)), + + new MysqlCharset(MYSQL_CHARSET_NAME_gb18030, 4, 0, new String[] { "GB18030" }, new ServerVersion(5, 7, 4)), + + new MysqlCharset(MYSQL_CHARSET_NAME_euckr, 2, 0, new String[] { "EUC-KR" }), + + new MysqlCharset(MYSQL_CHARSET_NAME_latin1, 1, 1, new String[] { "Cp1252", "ISO8859_1" }), + new MysqlCharset(MYSQL_CHARSET_NAME_swe7, 1, 0, new String[] { "Cp1252" }), + new MysqlCharset(MYSQL_CHARSET_NAME_hp8, 1, 0, new String[] { "Cp1252" }), + new MysqlCharset(MYSQL_CHARSET_NAME_dec8, 1, 0, new String[] { "Cp1252" }), + new MysqlCharset(MYSQL_CHARSET_NAME_armscii8, 1, 0, new String[] { "Cp1252" }), + new MysqlCharset(MYSQL_CHARSET_NAME_geostd8, 1, 0, new String[] { "Cp1252" }), + + new MysqlCharset(MYSQL_CHARSET_NAME_latin2, 1, 0, new String[] { "ISO8859_2" }), + new MysqlCharset(MYSQL_CHARSET_NAME_greek, 1, 0, new String[] { "ISO8859_7", "greek" }), + new MysqlCharset(MYSQL_CHARSET_NAME_latin7, 1, 0, new String[] { "ISO-8859-13" }), + new MysqlCharset(MYSQL_CHARSET_NAME_hebrew, 1, 0, new String[] { "ISO8859_8" }), + new MysqlCharset(MYSQL_CHARSET_NAME_latin5, 1, 0, new String[] { "ISO8859_9" }), + new MysqlCharset(MYSQL_CHARSET_NAME_cp850, 1, 0, new String[] { "Cp850", "Cp437" }), + + new MysqlCharset(MYSQL_CHARSET_NAME_cp852, 1, 0, new String[] { "Cp852" }), + new MysqlCharset(MYSQL_CHARSET_NAME_keybcs2, 1, 0, new String[] { "Cp852" }), // Kamenicky encoding usually known as Cp895 but there is no official cp895 specification; close to Cp852, see http://ftp.muni.cz/pub/localization/charsets/cs-encodings-faq + + new MysqlCharset(MYSQL_CHARSET_NAME_cp866, 1, 0, new String[] { "Cp866" }), + + new MysqlCharset(MYSQL_CHARSET_NAME_koi8r, 1, 1, new String[] { "KOI8_R" }), + new MysqlCharset(MYSQL_CHARSET_NAME_koi8u, 1, 0, new String[] { "KOI8_R" }), + + new MysqlCharset(MYSQL_CHARSET_NAME_tis620, 1, 0, new String[] { "TIS620" }), + new MysqlCharset(MYSQL_CHARSET_NAME_cp1250, 1, 0, new String[] { "Cp1250" }), + new MysqlCharset(MYSQL_CHARSET_NAME_cp1251, 1, 1, new String[] { "Cp1251" }), + new MysqlCharset(MYSQL_CHARSET_NAME_cp1256, 1, 0, new String[] { "Cp1256" }), + new MysqlCharset(MYSQL_CHARSET_NAME_cp1257, 1, 0, new String[] { "Cp1257" }), + new MysqlCharset(MYSQL_CHARSET_NAME_macroman, 1, 0, new String[] { "MacRoman" }), + new MysqlCharset(MYSQL_CHARSET_NAME_macce, 1, 0, new String[] { "MacCentralEurope" }), + + new MysqlCharset(MYSQL_CHARSET_NAME_utf8, 3, 0, new String[] { "UTF-8" }), + new MysqlCharset(MYSQL_CHARSET_NAME_utf8mb4, 4, 1, new String[] { "UTF-8" }), // "UTF-8 = *> 5.5.2 utf8mb4" + + new MysqlCharset(MYSQL_CHARSET_NAME_binary, 1, 1, new String[] { "ISO8859_1" }), + + new MysqlCharset(MYSQL_CHARSET_NAME_ucs2, 2, 0, new String[] { "UnicodeBig" }), + new MysqlCharset(MYSQL_CHARSET_NAME_utf16, 4, 0, new String[] { "UTF-16" }), + new MysqlCharset(MYSQL_CHARSET_NAME_utf16le, 4, 0, new String[] { "UTF-16LE" }), + new MysqlCharset(MYSQL_CHARSET_NAME_utf32, 4, 0, new String[] { "UTF-32" }) + + }; + HashMap charsetNameToMysqlCharsetMap = new HashMap<>(); + HashMap> javaUcToMysqlCharsetMap = new HashMap<>(); + Set tempMultibyteEncodings = new HashSet<>(); + + for (int i = 0; i < charset.length; i++) { + String charsetName = charset[i].charsetName; + charsetNameToMysqlCharsetMap.put(charsetName, charset[i]); + + for (String encUC : charset[i].javaEncodingsUc) { + List charsets = javaUcToMysqlCharsetMap.get(encUC); + if (charsets == null) { + charsets = new ArrayList<>(); + javaUcToMysqlCharsetMap.put(encUC, charsets); + } + charsets.add(charset[i]); + + if (charset[i].mblen > 1) { + tempMultibyteEncodings.add(encUC); + } + } + } + CHARSET_NAME_TO_CHARSET = Collections.unmodifiableMap(charsetNameToMysqlCharsetMap); + JAVA_ENCODING_UC_TO_MYSQL_CHARSET = Collections.unmodifiableMap(javaUcToMysqlCharsetMap); + MULTIBYTE_ENCODINGS = Collections.unmodifiableSet(tempMultibyteEncodings); + + // complete list of mysql collations and their corresponding character sets each element of collation[1]..collation[MAP_SIZE-1] must not be null + Collation[] collation = new Collation[MAP_SIZE]; + collation[1] = new Collation(1, "big5_chinese_ci", 1, MYSQL_CHARSET_NAME_big5); + collation[2] = new Collation(2, "latin2_czech_cs", 0, MYSQL_CHARSET_NAME_latin2); + collation[3] = new Collation(3, "dec8_swedish_ci", 0, MYSQL_CHARSET_NAME_dec8); + collation[4] = new Collation(4, "cp850_general_ci", 1, MYSQL_CHARSET_NAME_cp850); + collation[5] = new Collation(5, "latin1_german1_ci", 0, MYSQL_CHARSET_NAME_latin1); + collation[6] = new Collation(6, "hp8_english_ci", 0, MYSQL_CHARSET_NAME_hp8); + collation[7] = new Collation(7, "koi8r_general_ci", 0, MYSQL_CHARSET_NAME_koi8r); + collation[8] = new Collation(8, "latin1_swedish_ci", 1, MYSQL_CHARSET_NAME_latin1); + collation[9] = new Collation(9, "latin2_general_ci", 1, MYSQL_CHARSET_NAME_latin2); + collation[10] = new Collation(10, "swe7_swedish_ci", 0, MYSQL_CHARSET_NAME_swe7); + collation[11] = new Collation(11, "ascii_general_ci", 0, MYSQL_CHARSET_NAME_ascii); + collation[12] = new Collation(12, "ujis_japanese_ci", 0, MYSQL_CHARSET_NAME_ujis); + collation[13] = new Collation(13, "sjis_japanese_ci", 0, MYSQL_CHARSET_NAME_sjis); + collation[14] = new Collation(14, "cp1251_bulgarian_ci", 0, MYSQL_CHARSET_NAME_cp1251); + collation[15] = new Collation(15, "latin1_danish_ci", 0, MYSQL_CHARSET_NAME_latin1); + collation[16] = new Collation(16, "hebrew_general_ci", 0, MYSQL_CHARSET_NAME_hebrew); + + collation[18] = new Collation(18, "tis620_thai_ci", 0, MYSQL_CHARSET_NAME_tis620); + collation[19] = new Collation(19, "euckr_korean_ci", 0, MYSQL_CHARSET_NAME_euckr); + collation[20] = new Collation(20, "latin7_estonian_cs", 0, MYSQL_CHARSET_NAME_latin7); + collation[21] = new Collation(21, "latin2_hungarian_ci", 0, MYSQL_CHARSET_NAME_latin2); + collation[22] = new Collation(22, "koi8u_general_ci", 0, MYSQL_CHARSET_NAME_koi8u); + collation[23] = new Collation(23, "cp1251_ukrainian_ci", 0, MYSQL_CHARSET_NAME_cp1251); + collation[24] = new Collation(24, "gb2312_chinese_ci", 0, MYSQL_CHARSET_NAME_gb2312); + collation[25] = new Collation(25, "greek_general_ci", 0, MYSQL_CHARSET_NAME_greek); + collation[26] = new Collation(26, "cp1250_general_ci", 1, MYSQL_CHARSET_NAME_cp1250); + collation[27] = new Collation(27, "latin2_croatian_ci", 0, MYSQL_CHARSET_NAME_latin2); + collation[28] = new Collation(28, "gbk_chinese_ci", 1, MYSQL_CHARSET_NAME_gbk); + collation[29] = new Collation(29, "cp1257_lithuanian_ci", 0, MYSQL_CHARSET_NAME_cp1257); + collation[30] = new Collation(30, "latin5_turkish_ci", 1, MYSQL_CHARSET_NAME_latin5); + collation[31] = new Collation(31, "latin1_german2_ci", 0, MYSQL_CHARSET_NAME_latin1); + collation[32] = new Collation(32, "armscii8_general_ci", 0, MYSQL_CHARSET_NAME_armscii8); + collation[33] = new Collation(33, "utf8_general_ci", 1, MYSQL_CHARSET_NAME_utf8); + collation[34] = new Collation(34, "cp1250_czech_cs", 0, MYSQL_CHARSET_NAME_cp1250); + collation[35] = new Collation(35, "ucs2_general_ci", 1, MYSQL_CHARSET_NAME_ucs2); + collation[36] = new Collation(36, "cp866_general_ci", 1, MYSQL_CHARSET_NAME_cp866); + collation[37] = new Collation(37, "keybcs2_general_ci", 1, MYSQL_CHARSET_NAME_keybcs2); + collation[38] = new Collation(38, "macce_general_ci", 1, MYSQL_CHARSET_NAME_macce); + collation[39] = new Collation(39, "macroman_general_ci", 1, MYSQL_CHARSET_NAME_macroman); + collation[40] = new Collation(40, "cp852_general_ci", 1, MYSQL_CHARSET_NAME_cp852); + collation[41] = new Collation(41, "latin7_general_ci", 1, MYSQL_CHARSET_NAME_latin7); + collation[42] = new Collation(42, "latin7_general_cs", 0, MYSQL_CHARSET_NAME_latin7); + collation[43] = new Collation(43, "macce_bin", 0, MYSQL_CHARSET_NAME_macce); + collation[44] = new Collation(44, "cp1250_croatian_ci", 0, MYSQL_CHARSET_NAME_cp1250); + collation[45] = new Collation(45, "utf8mb4_general_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[46] = new Collation(46, "utf8mb4_bin", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[47] = new Collation(47, "latin1_bin", 0, MYSQL_CHARSET_NAME_latin1); + collation[48] = new Collation(48, "latin1_general_ci", 0, MYSQL_CHARSET_NAME_latin1); + collation[49] = new Collation(49, "latin1_general_cs", 0, MYSQL_CHARSET_NAME_latin1); + collation[50] = new Collation(50, "cp1251_bin", 0, MYSQL_CHARSET_NAME_cp1251); + collation[51] = new Collation(51, "cp1251_general_ci", 1, MYSQL_CHARSET_NAME_cp1251); + collation[52] = new Collation(52, "cp1251_general_cs", 0, MYSQL_CHARSET_NAME_cp1251); + collation[53] = new Collation(53, "macroman_bin", 0, MYSQL_CHARSET_NAME_macroman); + collation[54] = new Collation(54, "utf16_general_ci", 1, MYSQL_CHARSET_NAME_utf16); + collation[55] = new Collation(55, "utf16_bin", 0, MYSQL_CHARSET_NAME_utf16); + collation[56] = new Collation(56, "utf16le_general_ci", 1, MYSQL_CHARSET_NAME_utf16le); + collation[57] = new Collation(57, "cp1256_general_ci", 1, MYSQL_CHARSET_NAME_cp1256); + collation[58] = new Collation(58, "cp1257_bin", 0, MYSQL_CHARSET_NAME_cp1257); + collation[59] = new Collation(59, "cp1257_general_ci", 1, MYSQL_CHARSET_NAME_cp1257); + collation[60] = new Collation(60, "utf32_general_ci", 1, MYSQL_CHARSET_NAME_utf32); + collation[61] = new Collation(61, "utf32_bin", 0, MYSQL_CHARSET_NAME_utf32); + collation[62] = new Collation(62, "utf16le_bin", 0, MYSQL_CHARSET_NAME_utf16le); + collation[63] = new Collation(63, "binary", 1, MYSQL_CHARSET_NAME_binary); + collation[64] = new Collation(64, "armscii8_bin", 0, MYSQL_CHARSET_NAME_armscii8); + collation[65] = new Collation(65, "ascii_bin", 0, MYSQL_CHARSET_NAME_ascii); + collation[66] = new Collation(66, "cp1250_bin", 0, MYSQL_CHARSET_NAME_cp1250); + collation[67] = new Collation(67, "cp1256_bin", 0, MYSQL_CHARSET_NAME_cp1256); + collation[68] = new Collation(68, "cp866_bin", 0, MYSQL_CHARSET_NAME_cp866); + collation[69] = new Collation(69, "dec8_bin", 0, MYSQL_CHARSET_NAME_dec8); + collation[70] = new Collation(70, "greek_bin", 0, MYSQL_CHARSET_NAME_greek); + collation[71] = new Collation(71, "hebrew_bin", 0, MYSQL_CHARSET_NAME_hebrew); + collation[72] = new Collation(72, "hp8_bin", 0, MYSQL_CHARSET_NAME_hp8); + collation[73] = new Collation(73, "keybcs2_bin", 0, MYSQL_CHARSET_NAME_keybcs2); + collation[74] = new Collation(74, "koi8r_bin", 0, MYSQL_CHARSET_NAME_koi8r); + collation[75] = new Collation(75, "koi8u_bin", 0, MYSQL_CHARSET_NAME_koi8u); + collation[76] = new Collation(76, "utf8_tolower_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[77] = new Collation(77, "latin2_bin", 0, MYSQL_CHARSET_NAME_latin2); + collation[78] = new Collation(78, "latin5_bin", 0, MYSQL_CHARSET_NAME_latin5); + collation[79] = new Collation(79, "latin7_bin", 0, MYSQL_CHARSET_NAME_latin7); + collation[80] = new Collation(80, "cp850_bin", 0, MYSQL_CHARSET_NAME_cp850); + collation[81] = new Collation(81, "cp852_bin", 0, MYSQL_CHARSET_NAME_cp852); + collation[82] = new Collation(82, "swe7_bin", 0, MYSQL_CHARSET_NAME_swe7); + collation[83] = new Collation(83, "utf8_bin", 0, MYSQL_CHARSET_NAME_utf8); + collation[84] = new Collation(84, "big5_bin", 0, MYSQL_CHARSET_NAME_big5); + collation[85] = new Collation(85, "euckr_bin", 0, MYSQL_CHARSET_NAME_euckr); + collation[86] = new Collation(86, "gb2312_bin", 0, MYSQL_CHARSET_NAME_gb2312); + collation[87] = new Collation(87, "gbk_bin", 0, MYSQL_CHARSET_NAME_gbk); + collation[88] = new Collation(88, "sjis_bin", 0, MYSQL_CHARSET_NAME_sjis); + collation[89] = new Collation(89, "tis620_bin", 0, MYSQL_CHARSET_NAME_tis620); + collation[90] = new Collation(90, "ucs2_bin", 0, MYSQL_CHARSET_NAME_ucs2); + collation[91] = new Collation(91, "ujis_bin", 0, MYSQL_CHARSET_NAME_ujis); + collation[92] = new Collation(92, "geostd8_general_ci", 0, MYSQL_CHARSET_NAME_geostd8); + collation[93] = new Collation(93, "geostd8_bin", 0, MYSQL_CHARSET_NAME_geostd8); + collation[94] = new Collation(94, "latin1_spanish_ci", 0, MYSQL_CHARSET_NAME_latin1); + collation[95] = new Collation(95, "cp932_japanese_ci", 1, MYSQL_CHARSET_NAME_cp932); + collation[96] = new Collation(96, "cp932_bin", 0, MYSQL_CHARSET_NAME_cp932); + collation[97] = new Collation(97, "eucjpms_japanese_ci", 1, MYSQL_CHARSET_NAME_eucjpms); + collation[98] = new Collation(98, "eucjpms_bin", 0, MYSQL_CHARSET_NAME_eucjpms); + collation[99] = new Collation(99, "cp1250_polish_ci", 0, MYSQL_CHARSET_NAME_cp1250); + + collation[101] = new Collation(101, "utf16_unicode_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[102] = new Collation(102, "utf16_icelandic_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[103] = new Collation(103, "utf16_latvian_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[104] = new Collation(104, "utf16_romanian_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[105] = new Collation(105, "utf16_slovenian_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[106] = new Collation(106, "utf16_polish_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[107] = new Collation(107, "utf16_estonian_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[108] = new Collation(108, "utf16_spanish_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[109] = new Collation(109, "utf16_swedish_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[110] = new Collation(110, "utf16_turkish_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[111] = new Collation(111, "utf16_czech_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[112] = new Collation(112, "utf16_danish_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[113] = new Collation(113, "utf16_lithuanian_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[114] = new Collation(114, "utf16_slovak_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[115] = new Collation(115, "utf16_spanish2_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[116] = new Collation(116, "utf16_roman_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[117] = new Collation(117, "utf16_persian_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[118] = new Collation(118, "utf16_esperanto_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[119] = new Collation(119, "utf16_hungarian_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[120] = new Collation(120, "utf16_sinhala_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[121] = new Collation(121, "utf16_german2_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[122] = new Collation(122, "utf16_croatian_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[123] = new Collation(123, "utf16_unicode_520_ci", 0, MYSQL_CHARSET_NAME_utf16); + collation[124] = new Collation(124, "utf16_vietnamese_ci", 0, MYSQL_CHARSET_NAME_utf16); + + collation[128] = new Collation(128, "ucs2_unicode_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[129] = new Collation(129, "ucs2_icelandic_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[130] = new Collation(130, "ucs2_latvian_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[131] = new Collation(131, "ucs2_romanian_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[132] = new Collation(132, "ucs2_slovenian_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[133] = new Collation(133, "ucs2_polish_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[134] = new Collation(134, "ucs2_estonian_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[135] = new Collation(135, "ucs2_spanish_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[136] = new Collation(136, "ucs2_swedish_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[137] = new Collation(137, "ucs2_turkish_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[138] = new Collation(138, "ucs2_czech_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[139] = new Collation(139, "ucs2_danish_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[140] = new Collation(140, "ucs2_lithuanian_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[141] = new Collation(141, "ucs2_slovak_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[142] = new Collation(142, "ucs2_spanish2_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[143] = new Collation(143, "ucs2_roman_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[144] = new Collation(144, "ucs2_persian_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[145] = new Collation(145, "ucs2_esperanto_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[146] = new Collation(146, "ucs2_hungarian_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[147] = new Collation(147, "ucs2_sinhala_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[148] = new Collation(148, "ucs2_german2_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[149] = new Collation(149, "ucs2_croatian_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[150] = new Collation(150, "ucs2_unicode_520_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[151] = new Collation(151, "ucs2_vietnamese_ci", 0, MYSQL_CHARSET_NAME_ucs2); + + collation[159] = new Collation(159, "ucs2_general_mysql500_ci", 0, MYSQL_CHARSET_NAME_ucs2); + collation[160] = new Collation(160, "utf32_unicode_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[161] = new Collation(161, "utf32_icelandic_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[162] = new Collation(162, "utf32_latvian_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[163] = new Collation(163, "utf32_romanian_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[164] = new Collation(164, "utf32_slovenian_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[165] = new Collation(165, "utf32_polish_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[166] = new Collation(166, "utf32_estonian_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[167] = new Collation(167, "utf32_spanish_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[168] = new Collation(168, "utf32_swedish_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[169] = new Collation(169, "utf32_turkish_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[170] = new Collation(170, "utf32_czech_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[171] = new Collation(171, "utf32_danish_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[172] = new Collation(172, "utf32_lithuanian_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[173] = new Collation(173, "utf32_slovak_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[174] = new Collation(174, "utf32_spanish2_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[175] = new Collation(175, "utf32_roman_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[176] = new Collation(176, "utf32_persian_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[177] = new Collation(177, "utf32_esperanto_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[178] = new Collation(178, "utf32_hungarian_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[179] = new Collation(179, "utf32_sinhala_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[180] = new Collation(180, "utf32_german2_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[181] = new Collation(181, "utf32_croatian_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[182] = new Collation(182, "utf32_unicode_520_ci", 0, MYSQL_CHARSET_NAME_utf32); + collation[183] = new Collation(183, "utf32_vietnamese_ci", 0, MYSQL_CHARSET_NAME_utf32); + + collation[192] = new Collation(192, "utf8_unicode_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[193] = new Collation(193, "utf8_icelandic_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[194] = new Collation(194, "utf8_latvian_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[195] = new Collation(195, "utf8_romanian_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[196] = new Collation(196, "utf8_slovenian_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[197] = new Collation(197, "utf8_polish_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[198] = new Collation(198, "utf8_estonian_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[199] = new Collation(199, "utf8_spanish_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[200] = new Collation(200, "utf8_swedish_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[201] = new Collation(201, "utf8_turkish_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[202] = new Collation(202, "utf8_czech_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[203] = new Collation(203, "utf8_danish_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[204] = new Collation(204, "utf8_lithuanian_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[205] = new Collation(205, "utf8_slovak_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[206] = new Collation(206, "utf8_spanish2_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[207] = new Collation(207, "utf8_roman_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[208] = new Collation(208, "utf8_persian_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[209] = new Collation(209, "utf8_esperanto_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[210] = new Collation(210, "utf8_hungarian_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[211] = new Collation(211, "utf8_sinhala_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[212] = new Collation(212, "utf8_german2_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[213] = new Collation(213, "utf8_croatian_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[214] = new Collation(214, "utf8_unicode_520_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[215] = new Collation(215, "utf8_vietnamese_ci", 0, MYSQL_CHARSET_NAME_utf8); + + collation[223] = new Collation(223, "utf8_general_mysql500_ci", 0, MYSQL_CHARSET_NAME_utf8); + collation[224] = new Collation(224, "utf8mb4_unicode_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[225] = new Collation(225, "utf8mb4_icelandic_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[226] = new Collation(226, "utf8mb4_latvian_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[227] = new Collation(227, "utf8mb4_romanian_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[228] = new Collation(228, "utf8mb4_slovenian_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[229] = new Collation(229, "utf8mb4_polish_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[230] = new Collation(230, "utf8mb4_estonian_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[231] = new Collation(231, "utf8mb4_spanish_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[232] = new Collation(232, "utf8mb4_swedish_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[233] = new Collation(233, "utf8mb4_turkish_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[234] = new Collation(234, "utf8mb4_czech_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[235] = new Collation(235, "utf8mb4_danish_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[236] = new Collation(236, "utf8mb4_lithuanian_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[237] = new Collation(237, "utf8mb4_slovak_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[238] = new Collation(238, "utf8mb4_spanish2_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[239] = new Collation(239, "utf8mb4_roman_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[240] = new Collation(240, "utf8mb4_persian_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[241] = new Collation(241, "utf8mb4_esperanto_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[242] = new Collation(242, "utf8mb4_hungarian_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[243] = new Collation(243, "utf8mb4_sinhala_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[244] = new Collation(244, "utf8mb4_german2_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[245] = new Collation(245, "utf8mb4_croatian_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[246] = new Collation(246, "utf8mb4_unicode_520_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[247] = new Collation(247, "utf8mb4_vietnamese_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[248] = new Collation(248, "gb18030_chinese_ci", 1, MYSQL_CHARSET_NAME_gb18030); + collation[249] = new Collation(249, "gb18030_bin", 0, MYSQL_CHARSET_NAME_gb18030); + collation[250] = new Collation(250, "gb18030_unicode_520_ci", 0, MYSQL_CHARSET_NAME_gb18030); + + collation[255] = new Collation(255, "utf8mb4_0900_ai_ci", 1, MYSQL_CHARSET_NAME_utf8mb4); + collation[256] = new Collation(256, "utf8mb4_de_pb_0900_ai_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[257] = new Collation(257, "utf8mb4_is_0900_ai_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[258] = new Collation(258, "utf8mb4_lv_0900_ai_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[259] = new Collation(259, "utf8mb4_ro_0900_ai_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[260] = new Collation(260, "utf8mb4_sl_0900_ai_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[261] = new Collation(261, "utf8mb4_pl_0900_ai_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[262] = new Collation(262, "utf8mb4_et_0900_ai_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[263] = new Collation(263, "utf8mb4_es_0900_ai_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[264] = new Collation(264, "utf8mb4_sv_0900_ai_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[265] = new Collation(265, "utf8mb4_tr_0900_ai_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[266] = new Collation(266, "utf8mb4_cs_0900_ai_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[267] = new Collation(267, "utf8mb4_da_0900_ai_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[268] = new Collation(268, "utf8mb4_lt_0900_ai_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[269] = new Collation(269, "utf8mb4_sk_0900_ai_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[270] = new Collation(270, "utf8mb4_es_trad_0900_ai_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[271] = new Collation(271, "utf8mb4_la_0900_ai_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + + collation[273] = new Collation(273, "utf8mb4_eo_0900_ai_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[274] = new Collation(274, "utf8mb4_hu_0900_ai_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[275] = new Collation(275, "utf8mb4_hr_0900_ai_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + + collation[277] = new Collation(277, "utf8mb4_vi_0900_ai_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[278] = new Collation(278, "utf8mb4_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[279] = new Collation(279, "utf8mb4_de_pb_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[280] = new Collation(280, "utf8mb4_is_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[281] = new Collation(281, "utf8mb4_lv_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[282] = new Collation(282, "utf8mb4_ro_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[283] = new Collation(283, "utf8mb4_sl_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[284] = new Collation(284, "utf8mb4_pl_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[285] = new Collation(285, "utf8mb4_et_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[286] = new Collation(286, "utf8mb4_es_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[287] = new Collation(287, "utf8mb4_sv_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[288] = new Collation(288, "utf8mb4_tr_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[289] = new Collation(289, "utf8mb4_cs_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[290] = new Collation(290, "utf8mb4_da_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[291] = new Collation(291, "utf8mb4_lt_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[292] = new Collation(292, "utf8mb4_sk_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[293] = new Collation(293, "utf8mb4_es_trad_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[294] = new Collation(294, "utf8mb4_la_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + + collation[296] = new Collation(296, "utf8mb4_eo_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[297] = new Collation(297, "utf8mb4_hu_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[298] = new Collation(298, "utf8mb4_hr_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + + collation[300] = new Collation(300, "utf8mb4_vi_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + + collation[303] = new Collation(303, "utf8mb4_ja_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[304] = new Collation(304, "utf8mb4_ja_0900_as_cs_ks", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[305] = new Collation(305, "utf8mb4_0900_as_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[306] = new Collation(306, "utf8mb4_ru_0900_ai_ci", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[307] = new Collation(307, "utf8mb4_ru_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[308] = new Collation(308, "utf8mb4_zh_0900_as_cs", 0, MYSQL_CHARSET_NAME_utf8mb4); + collation[309] = new Collation(309, "utf8mb4_0900_bin", 0, MYSQL_CHARSET_NAME_utf8mb4); + + COLLATION_INDEX_TO_COLLATION_NAME = new String[MAP_SIZE]; + Map collationIndexToCharset = new TreeMap<>(); + Map charsetNameToCollationIndexMap = new TreeMap<>(); + Map charsetNameToCollationPriorityMap = new TreeMap<>(); + Map collationNameToCollationIndexMap = new TreeMap<>(); + Set impermissibleIndexes = new HashSet<>(); + + for (int i = 1; i < MAP_SIZE; i++) { + Collation coll = collation[i]; + if (coll != null) { + COLLATION_INDEX_TO_COLLATION_NAME[i] = coll.collationName; + collationIndexToCharset.put(i, coll.mysqlCharset); + collationNameToCollationIndexMap.put(coll.collationName, i); + String charsetName = coll.mysqlCharset.charsetName; + + if (!charsetNameToCollationIndexMap.containsKey(charsetName) || charsetNameToCollationPriorityMap.get(charsetName) < coll.priority) { + charsetNameToCollationIndexMap.put(charsetName, i); + charsetNameToCollationPriorityMap.put(charsetName, coll.priority); + } + + // Filling indexes of impermissible client character sets ucs2, utf16, utf16le, utf32 + if (charsetName.equals(MYSQL_CHARSET_NAME_ucs2) || charsetName.equals(MYSQL_CHARSET_NAME_utf16) + || charsetName.equals(MYSQL_CHARSET_NAME_utf16le) || charsetName.equals(MYSQL_CHARSET_NAME_utf32)) { + impermissibleIndexes.add(i); + } + } + } + + COLLATION_INDEX_TO_CHARSET = Collections.unmodifiableMap(collationIndexToCharset); + CHARSET_NAME_TO_COLLATION_INDEX = Collections.unmodifiableMap(charsetNameToCollationIndexMap); + COLLATION_NAME_TO_COLLATION_INDEX = Collections.unmodifiableMap(collationNameToCollationIndexMap); + IMPERMISSIBLE_INDEXES = Collections.unmodifiableSet(impermissibleIndexes); + + collation = null; + } + + protected static String getStaticMysqlCharsetForJavaEncoding(String javaEncoding, ServerVersion version) { + List mysqlCharsets = CharsetMapping.JAVA_ENCODING_UC_TO_MYSQL_CHARSET.get(javaEncoding.toUpperCase(Locale.ENGLISH)); + if (mysqlCharsets != null) { + if (version == null) { + return mysqlCharsets.get(0).charsetName; // Take the first one we get + } + MysqlCharset currentChoice = null; + for (MysqlCharset charset : mysqlCharsets) { + if (charset.isOkayForVersion(version) && (currentChoice == null || currentChoice.minimumVersion.compareTo(charset.minimumVersion) < 0 + || currentChoice.priority < charset.priority && currentChoice.minimumVersion.compareTo(charset.minimumVersion) == 0)) { + currentChoice = charset; + } + } + if (currentChoice != null) { + return currentChoice.charsetName; + } + } + return null; + } + + protected static int getStaticCollationIndexForJavaEncoding(String javaEncoding, ServerVersion version) { + String charsetName = getStaticMysqlCharsetForJavaEncoding(javaEncoding, version); + return getStaticCollationIndexForMysqlCharsetName(charsetName); + } + + protected static int getStaticCollationIndexForMysqlCharsetName(String charsetName) { + if (charsetName != null) { + Integer ci = CHARSET_NAME_TO_COLLATION_INDEX.get(charsetName); + if (ci != null) { + return ci.intValue(); + } + } + return 0; + } + + // TODO turn it to protected when com.mysql.cj.xdevapi.ColumnImpl can use dynamic maps + public static String getStaticMysqlCharsetNameForCollationIndex(Integer collationIndex) { + MysqlCharset charset = null; + if (collationIndex != null) { + charset = COLLATION_INDEX_TO_CHARSET.get(collationIndex); + } + return charset != null ? charset.charsetName : null; + } + + // TODO turn it to protected when com.mysql.cj.xdevapi.ColumnImpl can use dynamic maps + public static String getStaticCollationNameForCollationIndex(Integer collationIndex) { + if (collationIndex != null && collationIndex > 0 && collationIndex < MAP_SIZE) { + return COLLATION_INDEX_TO_COLLATION_NAME[collationIndex]; + } + return null; + } + + protected static Integer getStaticCollationIndexForCollationName(String collationName) { + return CharsetMapping.COLLATION_NAME_TO_COLLATION_INDEX.get(collationName); + } + + /** + * MySQL charset could map to several Java encodings. + * So here we choose the one according to next rules: + *
    + *
  • if there is no static mapping for this charset then return javaEncoding value as is because this + * could be a custom charset for example + *
  • if static mapping exists and javaEncoding equals to one of Java encoding canonical names or aliases available + * for this mapping then javaEncoding value as is; this is required when result should match to connection encoding, for example if connection encoding is + * Cp943 we must avoid getting SHIFT_JIS for sjis mysql charset + *
  • if static mapping exists and javaEncoding doesn't match any Java encoding canonical + * names or aliases available for this mapping then return default Java encoding (the first in mapping list) + *
+ * + * @param mysqlCharsetName + * MySQL charset name + * @param fallbackJavaEncoding + * fall-back java encoding name + * @return java encoding name + */ + protected static String getStaticJavaEncodingForMysqlCharset(String mysqlCharsetName, String fallbackJavaEncoding) { + MysqlCharset cs = getStaticMysqlCharsetByName(mysqlCharsetName); + return cs != null ? cs.getMatchingJavaEncoding(fallbackJavaEncoding) : fallbackJavaEncoding; + } + + protected static MysqlCharset getStaticMysqlCharsetByName(String mysqlCharsetName) { + return CHARSET_NAME_TO_CHARSET.get(mysqlCharsetName); + } + + protected static String getStaticJavaEncodingForMysqlCharset(String mysqlCharsetName) { + return getStaticJavaEncodingForMysqlCharset(mysqlCharsetName, null); + } + + protected static String getStaticJavaEncodingForCollationIndex(Integer collationIndex, String fallbackJavaEncoding) { + MysqlCharset charset = null; + if (collationIndex != null) { + charset = COLLATION_INDEX_TO_CHARSET.get(collationIndex); + } + return charset != null ? charset.getMatchingJavaEncoding(fallbackJavaEncoding) : fallbackJavaEncoding; + } + + // TODO turn it to protected when com.mysql.cj.protocol.x.FieldFactory can use dynamic maps + public static String getStaticJavaEncodingForCollationIndex(Integer collationIndex) { + return getStaticJavaEncodingForCollationIndex(collationIndex, null); + } + + /** + * Does the character set contain multi-byte encoded characters. + * + * @param javaEncodingName + * java encoding name + * @return true if the character set contains multi-byte encoded characters. + */ + protected static boolean isStaticMultibyteCharset(String javaEncodingName) { + return MULTIBYTE_ENCODINGS.contains(javaEncodingName.toUpperCase(Locale.ENGLISH)); + } + + protected static int getStaticMblen(String charsetName) { + if (charsetName != null) { + MysqlCharset cs = getStaticMysqlCharsetByName(charsetName); + if (cs != null) { + return cs.mblen; + } + } + return 0; + } + + protected static boolean isStaticImpermissibleCollation(int collationIndex) { + return CharsetMapping.IMPERMISSIBLE_INDEXES.contains(collationIndex); + } + +} + +class MysqlCharset { + public final String charsetName; + public final int mblen; + public final int priority; + public final List javaEncodingsUc = new ArrayList<>(); + + public final ServerVersion minimumVersion; + + /** + * Constructs MysqlCharset object + * + * @param charsetName + * MySQL charset name + * @param mblen + * Max number of bytes per character + * @param priority + * MysqlCharset with highest value of this param will be used for Java encoding --> Mysql charsets conversion. + * @param javaEncodings + * List of Java encodings corresponding to this MySQL charset; the first name in list is the default for mysql --> java data conversion + */ + public MysqlCharset(String charsetName, int mblen, int priority, String[] javaEncodings) { + this(charsetName, mblen, priority, javaEncodings, new ServerVersion(0, 0, 0)); + } + + private void addEncodingMapping(String encoding) { + String encodingUc = encoding.toUpperCase(Locale.ENGLISH); + + if (!this.javaEncodingsUc.contains(encodingUc)) { + this.javaEncodingsUc.add(encodingUc); + } + } + + public MysqlCharset(String charsetName, int mblen, int priority, String[] javaEncodings, ServerVersion minimumVersion) { + this.charsetName = charsetName; + this.mblen = mblen; + this.priority = priority; + + for (int i = 0; i < javaEncodings.length; i++) { + String encoding = javaEncodings[i]; + try { + Charset cs = Charset.forName(encoding); + addEncodingMapping(cs.name()); + cs.aliases().forEach(this::addEncodingMapping); + } catch (Exception e) { + // if there is no support of this charset in JVM it's still possible to use our converter for 1-byte charsets + if (mblen == 1) { + addEncodingMapping(encoding); + } + } + } + + if (this.javaEncodingsUc.size() == 0) { + addEncodingMapping(mblen > 1 ? "UTF-8" : "Cp1252"); + } + + this.minimumVersion = minimumVersion; + } + + @Override + public String toString() { + StringBuilder asString = new StringBuilder(); + asString.append("["); + asString.append("charsetName="); + asString.append(this.charsetName); + asString.append(",mblen="); + asString.append(this.mblen); + // asString.append(",javaEncoding="); + // asString.append(this.javaEncodings.toString()); + asString.append("]"); + return asString.toString(); + } + + boolean isOkayForVersion(ServerVersion version) { + return version.meetsMinimum(this.minimumVersion); + } + + /** + * If javaEncoding parameter value is one of available java encodings for this charset + * then returns javaEncoding value as is. Otherwise returns first available java encoding name. + * + * @param javaEncoding + * java encoding name + * @return java encoding name + */ + String getMatchingJavaEncoding(String javaEncoding) { + if (javaEncoding != null && this.javaEncodingsUc.contains(javaEncoding.toUpperCase(Locale.ENGLISH))) { + return javaEncoding; + } + return this.javaEncodingsUc.get(0); + } +} + +class Collation { + public final int index; + public final String collationName; + public final int priority; + public final MysqlCharset mysqlCharset; + + public Collation(int index, String collationName, int priority, String charsetName) { + this.index = index; + this.collationName = collationName; + this.priority = priority; + this.mysqlCharset = CharsetMapping.getStaticMysqlCharsetByName(charsetName); + } + + @Override + public String toString() { + StringBuilder asString = new StringBuilder(); + asString.append("["); + asString.append("index="); + asString.append(this.index); + asString.append(",collationName="); + asString.append(this.collationName); + asString.append(",charsetName="); + asString.append(this.mysqlCharset.charsetName); + asString.append(",javaCharsetName="); + asString.append(this.mysqlCharset.getMatchingJavaEncoding(null)); + asString.append("]"); + return asString.toString(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/CharsetSettings.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/CharsetSettings.java new file mode 100644 index 0000000..e6cd54a --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/CharsetSettings.java @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +public interface CharsetSettings { + + public static final String CHARACTER_SET_CLIENT = "character_set_client"; + public static final String CHARACTER_SET_CONNECTION = "character_set_connection"; + public static final String CHARACTER_SET_RESULTS = "character_set_results"; + public static final String COLLATION_CONNECTION = "collation_connection"; + + /** + *

+ * Choose the MySQL collation index for the handshake packet and the corresponding Java encodings for the password and error messages. + *

+ *

+ * This index will be sent with HandshakeResponse setting server variables 'character_set_connection', 'collation_connection', 'character_set_client' + * and 'character_set_results' which will be used by the server for decoding passwords during the authentication phase and later on, if + * no SET NAMES are issued by {@link #configurePostHandshake(boolean)}. + *

+ *

+ * It also means that collation index should be set according to: + *

    + *
  1. 'passwordCharacterEncoding' if it's present, or + *
  2. 'connectionCollation' if it's present, or + *
  3. 'characterEncoding' if it's present + *
+ * otherwise it will be set to utf8mb4_general_ci or utf8mb4_0900_ai_ci depending on server version. + *

+ * Since Protocol::HandshakeV10 and Protocol::HandshakeResponse41 has only one byte for the collation it's not possible to use indexes > 255 during the + * handshake. + * Also, ucs2, utf16, utf16le and utf32 character sets are impermissible here. Connector/J will try to use utf8mb4 instead. + *

+ * + * @param reset + * reset the charsets configuration; needed for changeUser call. + * + * @return MySQL collation index to be used during the handshake. + */ + int configurePreHandshake(boolean reset); + + /** + * Sets up client character set. This must be done before any further communication with the server! + * + * The 'collation_connection', 'character_set_client', 'character_set_connection' and 'character_set_results' server variables are set + * according to the collation index selected by {@link #configurePreHandshake(boolean)} and sent in the Protocol::HandshakeV10 packet. + * Here Connector/J alters these server variables if needed. + * + * @param dontCheckServerMatch + * if true then send the SET NAMES query even if server charset already matches the new value; needed for changeUser call. + */ + void configurePostHandshake(boolean dontCheckServerMatch); + + public boolean doesPlatformDbCharsetMatches(); + + String getPasswordCharacterEncoding(); + + String getErrorMessageEncoding(); + + String getMetadataEncoding(); + + int getMetadataCollationIndex(); + + boolean getRequiresEscapingEncoder(); + + String getJavaEncodingForCollationIndex(int collationIndex); + + int getMaxBytesPerChar(String javaCharsetName); + + int getMaxBytesPerChar(Integer charsetIndex, String javaCharsetName); + + Integer getCollationIndexForCollationName(String collationName); + + String getCollationNameForCollationIndex(Integer collationIndex); + + String getMysqlCharsetNameForCollationIndex(Integer collationIndex); + + int getCollationIndexForJavaEncoding(String javaEncoding, ServerVersion version); + + int getCollationIndexForMysqlCharsetName(String charsetName); + + String getJavaEncodingForMysqlCharset(String mysqlCharsetName); + + String getMysqlCharsetForJavaEncoding(String javaEncoding, ServerVersion version); + + boolean isMultibyteCharset(String javaEncodingName); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/Constants.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/Constants.java new file mode 100644 index 0000000..cc918e6 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/Constants.java @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2002, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.math.BigDecimal; +import java.math.BigInteger; + +import com.mysql.cj.conf.PropertyDefinitions; + +/** + * Represents various constants used in the driver. + */ +public class Constants { + /** + * Avoids allocation of empty byte[] when representing 0-length strings. + */ + public final static byte[] EMPTY_BYTE_ARRAY = new byte[0]; + + /** + * I18N'd representation of the abbreviation for "ms" + */ + public final static String MILLIS_I18N = Messages.getString("Milliseconds"); + + public final static byte[] SLASH_STAR_SPACE_AS_BYTES = new byte[] { (byte) '/', (byte) '*', (byte) ' ' }; + + public final static byte[] SPACE_STAR_SLASH_SPACE_AS_BYTES = new byte[] { (byte) ' ', (byte) '*', (byte) '/', (byte) ' ' }; + + public static final String JVM_VENDOR = System.getProperty(PropertyDefinitions.SYSP_java_vendor); + public static final String JVM_VERSION = System.getProperty(PropertyDefinitions.SYSP_java_version); + + public static final String OS_NAME = System.getProperty(PropertyDefinitions.SYSP_os_name); + public static final String OS_ARCH = System.getProperty(PropertyDefinitions.SYSP_os_arch); + public static final String OS_VERSION = System.getProperty(PropertyDefinitions.SYSP_os_version); + public static final String PLATFORM_ENCODING = System.getProperty(PropertyDefinitions.SYSP_file_encoding); + + public static final String CJ_NAME = "@MYSQL_CJ_DISPLAY_PROD_NAME@"; + public static final String CJ_FULL_NAME = "@MYSQL_CJ_FULL_PROD_NAME@"; + public static final String CJ_REVISION = "@MYSQL_CJ_REVISION@"; + public static final String CJ_VERSION = "@MYSQL_CJ_VERSION@"; + public static final String CJ_MAJOR_VERSION = "@MYSQL_CJ_MAJOR_VERSION@"; + public static final String CJ_MINOR_VERSION = "@MYSQL_CJ_MINOR_VERSION@"; + public static final String CJ_LICENSE = "@MYSQL_CJ_LICENSE_TYPE@"; + + public static final BigInteger BIG_INTEGER_ZERO = BigInteger.valueOf(0); + public static final BigInteger BIG_INTEGER_ONE = BigInteger.valueOf(1); + public static final BigInteger BIG_INTEGER_NEGATIVE_ONE = BigInteger.valueOf(-1); + public static final BigInteger BIG_INTEGER_MIN_BYTE_VALUE = BigInteger.valueOf(Byte.MIN_VALUE); + public static final BigInteger BIG_INTEGER_MAX_BYTE_VALUE = BigInteger.valueOf(Byte.MAX_VALUE); + public static final BigInteger BIG_INTEGER_MIN_SHORT_VALUE = BigInteger.valueOf(Short.MIN_VALUE); + public static final BigInteger BIG_INTEGER_MAX_SHORT_VALUE = BigInteger.valueOf(Short.MAX_VALUE); + public static final BigInteger BIG_INTEGER_MIN_INTEGER_VALUE = BigInteger.valueOf(Integer.MIN_VALUE); + public static final BigInteger BIG_INTEGER_MAX_INTEGER_VALUE = BigInteger.valueOf(Integer.MAX_VALUE); + public static final BigInteger BIG_INTEGER_MIN_LONG_VALUE = BigInteger.valueOf(Long.MIN_VALUE); + public static final BigInteger BIG_INTEGER_MAX_LONG_VALUE = BigInteger.valueOf(Long.MAX_VALUE); + + public static final BigDecimal BIG_DECIMAL_ZERO = BigDecimal.valueOf(0); + public static final BigDecimal BIG_DECIMAL_ONE = BigDecimal.valueOf(1); + public static final BigDecimal BIG_DECIMAL_NEGATIVE_ONE = BigDecimal.valueOf(-1); + public static final BigDecimal BIG_DECIMAL_MIN_BYTE_VALUE = BigDecimal.valueOf(Byte.MIN_VALUE); + public static final BigDecimal BIG_DECIMAL_MAX_BYTE_VALUE = BigDecimal.valueOf(Byte.MAX_VALUE); + public static final BigDecimal BIG_DECIMAL_MIN_SHORT_VALUE = BigDecimal.valueOf(Short.MIN_VALUE); + public static final BigDecimal BIG_DECIMAL_MAX_SHORT_VALUE = BigDecimal.valueOf(Short.MAX_VALUE); + public static final BigDecimal BIG_DECIMAL_MIN_INTEGER_VALUE = BigDecimal.valueOf(Integer.MIN_VALUE); + public static final BigDecimal BIG_DECIMAL_MAX_INTEGER_VALUE = BigDecimal.valueOf(Integer.MAX_VALUE); + public static final BigDecimal BIG_DECIMAL_MIN_LONG_VALUE = BigDecimal.valueOf(Long.MIN_VALUE); + public static final BigDecimal BIG_DECIMAL_MAX_LONG_VALUE = BigDecimal.valueOf(Long.MAX_VALUE); + public static final BigDecimal BIG_DECIMAL_MAX_DOUBLE_VALUE = BigDecimal.valueOf(Double.MAX_VALUE); + public static final BigDecimal BIG_DECIMAL_MAX_NEGATIVE_DOUBLE_VALUE = BigDecimal.valueOf(-Double.MAX_VALUE); + public static final BigDecimal BIG_DECIMAL_MAX_FLOAT_VALUE = BigDecimal.valueOf(Float.MAX_VALUE); + public static final BigDecimal BIG_DECIMAL_MAX_NEGATIVE_FLOAT_VALUE = BigDecimal.valueOf(-Float.MAX_VALUE); + + public static final int UNSIGNED_BYTE_MAX_VALUE = 255; + + /** + * Prevents instantiation + */ + private Constants() { + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/DataStoreMetadata.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/DataStoreMetadata.java new file mode 100644 index 0000000..935cf52 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/DataStoreMetadata.java @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2018, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +public interface DataStoreMetadata { + + boolean schemaExists(String schemaName); + + boolean tableExists(String schemaName, String tableName); + + long getTableRowCount(String schemaName, String tableName); + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/MessageBuilder.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/MessageBuilder.java new file mode 100644 index 0000000..19a4b66 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/MessageBuilder.java @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2018, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.util.List; + +import com.mysql.cj.protocol.Message; + +public interface MessageBuilder { + + M buildSqlStatement(String statement); + + M buildSqlStatement(String statement, List args); + + M buildClose(); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/Messages.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/Messages.java new file mode 100644 index 0000000..d304952 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/Messages.java @@ -0,0 +1,108 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.text.MessageFormat; +import java.util.Locale; +import java.util.MissingResourceException; +import java.util.ResourceBundle; + +/** + * Support for localized messages. + */ +public class Messages { + private static final String BUNDLE_NAME = "com.mysql.cj.LocalizedErrorMessages"; + + private static final ResourceBundle RESOURCE_BUNDLE; + private static final Object[] emptyObjectArray = {}; + + static { + ResourceBundle temp = null; + + // + // Overly-pedantic here, some appserver and JVM combos don't deal well with the no-args version, others don't deal well with the three-arg version, so + // we need to try both :( + // + + try { + temp = ResourceBundle.getBundle(BUNDLE_NAME, Locale.getDefault(), Messages.class.getClassLoader()); + } catch (Throwable t) { + try { + temp = ResourceBundle.getBundle(BUNDLE_NAME); + } catch (Throwable t2) { + RuntimeException rt = new RuntimeException("Can't load resource bundle due to underlying exception " + t.toString()); + rt.initCause(t2); + + throw rt; + } + } finally { + RESOURCE_BUNDLE = temp; + } + } + + /** + * Returns the localized message for the given message key + * + * @param key + * the message key + * @return The localized message for the key + */ + public static String getString(String key) { + return getString(key, emptyObjectArray); + } + + public static String getString(String key, Object[] args) { + if (RESOURCE_BUNDLE == null) { + throw new RuntimeException("Localized messages from resource bundle '" + BUNDLE_NAME + "' not loaded during initialization of driver."); + } + + try { + if (key == null) { + throw new IllegalArgumentException("Message key can not be null"); + } + + String message = RESOURCE_BUNDLE.getString(key); + + if (message == null) { + message = "Missing error message for key '" + key + "'"; + } + + return MessageFormat.format(message, args); + } catch (MissingResourceException e) { + return '!' + key + '!'; + } + } + + /** + * Dis-allow construction ... + */ + private Messages() { + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/MysqlConnection.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/MysqlConnection.java new file mode 100644 index 0000000..5b1dfe1 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/MysqlConnection.java @@ -0,0 +1,82 @@ +/* + * Copyright (c) 2015, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.util.Properties; + +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.ExceptionInterceptor; +import com.mysql.cj.protocol.ServerSessionStateController; + +public interface MysqlConnection { + + PropertySet getPropertySet(); + + /** + * Creates an IO channel to the server. + * + * @param isForReconnect + * is this request for a re-connect + */ + void createNewIO(boolean isForReconnect); + + long getId(); + + /** + * Returns the parsed and passed in properties for this connection. + * + * @return {@link Properties} + */ + Properties getProperties(); + + Object getConnectionMutex(); + + Session getSession(); + + String getURL(); + + String getUser(); + + ExceptionInterceptor getExceptionInterceptor(); + + void checkClosed(); + + void normalClose(); + + /** + * Destroys this connection and any underlying resources. + * + * @param whyCleanedUp + * exception caused the connection clean up + */ + void cleanup(Throwable whyCleanedUp); + + ServerSessionStateController getServerSessionStateController(); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/MysqlType.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/MysqlType.java new file mode 100644 index 0000000..dfd3173 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/MysqlType.java @@ -0,0 +1,1034 @@ +/* + * Copyright (c) 2015, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.sql.Date; +import java.sql.SQLType; +import java.sql.Time; +import java.sql.Timestamp; +import java.sql.Types; +import java.time.LocalDateTime; + +import com.mysql.cj.exceptions.FeatureNotAvailableException; +import com.mysql.cj.util.StringUtils; + +public enum MysqlType implements SQLType { + + /** + * DECIMAL[(M[,D])] [UNSIGNED] [ZEROFILL] + * A packed "exact" fixed-point number. M is the total number of digits (the precision) and D is the number of digits + * after the decimal point (the scale). The decimal point and (for negative numbers) the "-" sign are not counted in M. + * If D is 0, values have no decimal point or fractional part. The maximum number of digits (M) for DECIMAL is 65. + * The maximum number of supported decimals (D) is 30. If D is omitted, the default is 0. If M is omitted, the default is 10. + * + * Protocol: FIELD_TYPE_DECIMAL = 0 + * Protocol: FIELD_TYPE_NEWDECIMAL = 246 + * + * These types are synonyms for DECIMAL: + * DEC[(M[,D])] [UNSIGNED] [ZEROFILL], + * NUMERIC[(M[,D])] [UNSIGNED] [ZEROFILL], + * FIXED[(M[,D])] [UNSIGNED] [ZEROFILL] + */ + DECIMAL("DECIMAL", Types.DECIMAL, BigDecimal.class, MysqlType.FIELD_FLAG_ZEROFILL, MysqlType.IS_DECIMAL, 65L, "[(M[,D])] [UNSIGNED] [ZEROFILL]"), + /** + * DECIMAL[(M[,D])] UNSIGNED [ZEROFILL] + * + * @see MysqlType#DECIMAL + */ + DECIMAL_UNSIGNED("DECIMAL UNSIGNED", Types.DECIMAL, BigDecimal.class, MysqlType.FIELD_FLAG_UNSIGNED | MysqlType.FIELD_FLAG_ZEROFILL, MysqlType.IS_DECIMAL, + 65L, "[(M[,D])] [UNSIGNED] [ZEROFILL]"), + /** + * TINYINT[(M)] [UNSIGNED] [ZEROFILL] + * A very small integer. The signed range is -128 to 127. The unsigned range is 0 to 255. + * + * Protocol: FIELD_TYPE_TINY = 1 + */ + TINYINT("TINYINT", Types.TINYINT, Integer.class, MysqlType.FIELD_FLAG_ZEROFILL, MysqlType.IS_DECIMAL, 3L, "[(M)] [UNSIGNED] [ZEROFILL]"), + /** + * TINYINT[(M)] UNSIGNED [ZEROFILL] + * + * @see MysqlType#TINYINT + */ + TINYINT_UNSIGNED("TINYINT UNSIGNED", Types.TINYINT, Integer.class, MysqlType.FIELD_FLAG_UNSIGNED | MysqlType.FIELD_FLAG_ZEROFILL, MysqlType.IS_DECIMAL, 3L, + "[(M)] [UNSIGNED] [ZEROFILL]"), + /** + * BOOL, BOOLEAN + * These types are synonyms for TINYINT(1). A value of zero is considered false. Nonzero values are considered true + * + * BOOLEAN is converted to TINYINT(1) during DDL execution i.e. it has the same precision=3. Thus we have to + * look at full data type name and convert TINYINT to BOOLEAN (or BIT) if it has "(1)" length specification. + * + * Protocol: FIELD_TYPE_TINY = 1 + */ + BOOLEAN("BOOLEAN", Types.BOOLEAN, Boolean.class, 0, MysqlType.IS_NOT_DECIMAL, 3L, ""), + /** + * SMALLINT[(M)] [UNSIGNED] [ZEROFILL] + * A small integer. The signed range is -32768 to 32767. The unsigned range is 0 to 65535. + * + * Protocol: FIELD_TYPE_SHORT = 2 + */ + SMALLINT("SMALLINT", Types.SMALLINT, Integer.class, MysqlType.FIELD_FLAG_ZEROFILL, MysqlType.IS_DECIMAL, 5L, "[(M)] [UNSIGNED] [ZEROFILL]"), + /** + * SMALLINT[(M)] UNSIGNED [ZEROFILL] + * + * @see MysqlType#SMALLINT + */ + SMALLINT_UNSIGNED("SMALLINT UNSIGNED", Types.SMALLINT, Integer.class, MysqlType.FIELD_FLAG_UNSIGNED | MysqlType.FIELD_FLAG_ZEROFILL, MysqlType.IS_DECIMAL, + 5L, "[(M)] [UNSIGNED] [ZEROFILL]"), + /** + * INT[(M)] [UNSIGNED] [ZEROFILL] + * A normal-size integer. The signed range is -2147483648 to 2147483647. The unsigned range is 0 to 4294967295. + * + * Protocol: FIELD_TYPE_LONG = 3 + * + * INTEGER[(M)] [UNSIGNED] [ZEROFILL] is a synonym for INT. + */ + INT("INT", Types.INTEGER, Integer.class, MysqlType.FIELD_FLAG_ZEROFILL, MysqlType.IS_DECIMAL, 10L, "[(M)] [UNSIGNED] [ZEROFILL]"), + /** + * INT[(M)] UNSIGNED [ZEROFILL] + * + * @see MysqlType#INT + */ + INT_UNSIGNED("INT UNSIGNED", Types.INTEGER, Long.class, MysqlType.FIELD_FLAG_UNSIGNED | MysqlType.FIELD_FLAG_ZEROFILL, MysqlType.IS_DECIMAL, 10L, + "[(M)] [UNSIGNED] [ZEROFILL]"), + /** + * FLOAT[(M,D)] [UNSIGNED] [ZEROFILL] + * A small (single-precision) floating-point number. Permissible values are -3.402823466E+38 to -1.175494351E-38, 0, + * and 1.175494351E-38 to 3.402823466E+38. These are the theoretical limits, based on the IEEE standard. The actual + * range might be slightly smaller depending on your hardware or operating system. + * + * M is the total number of digits and D is the number of digits following the decimal point. If M and D are omitted, + * values are stored to the limits permitted by the hardware. A single-precision floating-point number is accurate to + * approximately 7 decimal places. + * + * Protocol: FIELD_TYPE_FLOAT = 4 + * + * Additionally: + * FLOAT(p) [UNSIGNED] [ZEROFILL] + * A floating-point number. p represents the precision in bits, but MySQL uses this value only to determine whether + * to use FLOAT or DOUBLE for the resulting data type. If p is from 0 to 24, the data type becomes FLOAT with no M or D values. + * If p is from 25 to 53, the data type becomes DOUBLE with no M or D values. The range of the resulting column is the same as + * for the single-precision FLOAT or double-precision DOUBLE data types. + */ + FLOAT("FLOAT", Types.REAL, Float.class, MysqlType.FIELD_FLAG_ZEROFILL, MysqlType.IS_DECIMAL, 12L, "[(M,D)] [UNSIGNED] [ZEROFILL]"), + /** + * FLOAT[(M,D)] UNSIGNED [ZEROFILL] + * + * @see MysqlType#FLOAT + */ + FLOAT_UNSIGNED("FLOAT UNSIGNED", Types.REAL, Float.class, MysqlType.FIELD_FLAG_UNSIGNED | MysqlType.FIELD_FLAG_ZEROFILL, MysqlType.IS_DECIMAL, 12L, + "[(M,D)] [UNSIGNED] [ZEROFILL]"), + /** + * DOUBLE[(M,D)] [UNSIGNED] [ZEROFILL] + * A normal-size (double-precision) floating-point number. Permissible values are -1.7976931348623157E+308 to + * -2.2250738585072014E-308, 0, and 2.2250738585072014E-308 to 1.7976931348623157E+308. These are the theoretical limits, + * based on the IEEE standard. The actual range might be slightly smaller depending on your hardware or operating system. + * + * M is the total number of digits and D is the number of digits following the decimal point. If M and D are omitted, + * values are stored to the limits permitted by the hardware. A double-precision floating-point number is accurate to + * approximately 15 decimal places. + * + * Protocol: FIELD_TYPE_DOUBLE = 5 + * + * These types are synonyms for DOUBLE: + * DOUBLE PRECISION[(M,D)] [UNSIGNED] [ZEROFILL], + * REAL[(M,D)] [UNSIGNED] [ZEROFILL]. Exception: If the REAL_AS_FLOAT SQL mode is enabled, REAL is a synonym for FLOAT rather than DOUBLE. + */ + DOUBLE("DOUBLE", Types.DOUBLE, Double.class, MysqlType.FIELD_FLAG_ZEROFILL, MysqlType.IS_DECIMAL, 22L, "[(M,D)] [UNSIGNED] [ZEROFILL]"), + /** + * DOUBLE[(M,D)] UNSIGNED [ZEROFILL] + * + * @see MysqlType#DOUBLE + */ + DOUBLE_UNSIGNED("DOUBLE UNSIGNED", Types.DOUBLE, Double.class, MysqlType.FIELD_FLAG_UNSIGNED | MysqlType.FIELD_FLAG_ZEROFILL, MysqlType.IS_DECIMAL, 22L, + "[(M,D)] [UNSIGNED] [ZEROFILL]"), + /** + * FIELD_TYPE_NULL = 6 + */ + NULL("NULL", Types.NULL, Object.class, 0, MysqlType.IS_NOT_DECIMAL, 0L, ""), + /** + * TIMESTAMP[(fsp)] + * A timestamp. The range is '1970-01-01 00:00:01.000000' UTC to '2038-01-19 03:14:07.999999' UTC. + * TIMESTAMP values are stored as the number of seconds since the epoch ('1970-01-01 00:00:00' UTC). + * A TIMESTAMP cannot represent the value '1970-01-01 00:00:00' because that is equivalent to 0 seconds + * from the epoch and the value 0 is reserved for representing '0000-00-00 00:00:00', the "zero" TIMESTAMP value. + * An optional fsp value in the range from 0 to 6 may be given to specify fractional seconds precision. A value + * of 0 signifies that there is no fractional part. If omitted, the default precision is 0. + * + * Protocol: FIELD_TYPE_TIMESTAMP = 7 + * + */ + // TODO If MySQL server run with the MAXDB SQL mode enabled, TIMESTAMP is identical with DATETIME. If this mode is enabled at the time that a table is created, TIMESTAMP columns are created as DATETIME columns. + // As a result, such columns use DATETIME display format, have the same range of values, and there is no automatic initialization or updating to the current date and time + TIMESTAMP("TIMESTAMP", Types.TIMESTAMP, Timestamp.class, 0, MysqlType.IS_NOT_DECIMAL, 26L, "[(fsp)]"), + /** + * BIGINT[(M)] [UNSIGNED] [ZEROFILL] + * A large integer. The signed range is -9223372036854775808 to 9223372036854775807. The unsigned range is 0 to 18446744073709551615. + * + * Protocol: FIELD_TYPE_LONGLONG = 8 + * + * SERIAL is an alias for BIGINT UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE. + */ + BIGINT("BIGINT", Types.BIGINT, Long.class, MysqlType.FIELD_FLAG_ZEROFILL, MysqlType.IS_DECIMAL, 19L, "[(M)] [UNSIGNED] [ZEROFILL]"), + /** + * BIGINT[(M)] UNSIGNED [ZEROFILL] + * + * @see MysqlType#BIGINT + */ + BIGINT_UNSIGNED("BIGINT UNSIGNED", Types.BIGINT, BigInteger.class, MysqlType.FIELD_FLAG_UNSIGNED | MysqlType.FIELD_FLAG_ZEROFILL, MysqlType.IS_DECIMAL, 20L, + "[(M)] [UNSIGNED] [ZEROFILL]"), + /** + * MEDIUMINT[(M)] [UNSIGNED] [ZEROFILL] + * A medium-sized integer. The signed range is -8388608 to 8388607. The unsigned range is 0 to 16777215. + * + * Protocol: FIELD_TYPE_INT24 = 9 + */ + MEDIUMINT("MEDIUMINT", Types.INTEGER, Integer.class, MysqlType.FIELD_FLAG_ZEROFILL, MysqlType.IS_DECIMAL, 7L, "[(M)] [UNSIGNED] [ZEROFILL]"), + /** + * MEDIUMINT[(M)] UNSIGNED [ZEROFILL] + * + * @see MysqlType#MEDIUMINT + */ + MEDIUMINT_UNSIGNED("MEDIUMINT UNSIGNED", Types.INTEGER, Integer.class, MysqlType.FIELD_FLAG_UNSIGNED | MysqlType.FIELD_FLAG_ZEROFILL, MysqlType.IS_DECIMAL, + 8L, "[(M)] [UNSIGNED] [ZEROFILL]"), + /** + * DATE + * A date. The supported range is '1000-01-01' to '9999-12-31'. MySQL displays DATE values in 'YYYY-MM-DD' format, + * but permits assignment of values to DATE columns using either strings or numbers. + * + * Protocol: FIELD_TYPE_DATE = 10 + */ + DATE("DATE", Types.DATE, Date.class, 0, MysqlType.IS_NOT_DECIMAL, 10L, ""), + /** + * TIME[(fsp)] + * A time. The range is '-838:59:59.000000' to '838:59:59.000000'. MySQL displays TIME values in + * 'HH:MM:SS[.fraction]' format, but permits assignment of values to TIME columns using either strings or numbers. + * An optional fsp value in the range from 0 to 6 may be given to specify fractional seconds precision. A value + * of 0 signifies that there is no fractional part. If omitted, the default precision is 0. + * + * Protocol: FIELD_TYPE_TIME = 11 + */ + TIME("TIME", Types.TIME, Time.class, 0, MysqlType.IS_NOT_DECIMAL, 16L, "[(fsp)]"), + /** + * DATETIME[(fsp)] + * A date and time combination. The supported range is '1000-01-01 00:00:00.000000' to '9999-12-31 23:59:59.999999'. + * MySQL displays DATETIME values in 'YYYY-MM-DD HH:MM:SS[.fraction]' format, but permits assignment of values to + * DATETIME columns using either strings or numbers. + * An optional fsp value in the range from 0 to 6 may be given to specify fractional seconds precision. A value + * of 0 signifies that there is no fractional part. If omitted, the default precision is 0. + * + * Protocol: FIELD_TYPE_DATETIME = 12 + */ + DATETIME("DATETIME", Types.TIMESTAMP, LocalDateTime.class, 0, MysqlType.IS_NOT_DECIMAL, 26L, "[(fsp)]"), + /** + * YEAR[(4)] + * A year in four-digit format. MySQL displays YEAR values in YYYY format, but permits assignment of + * values to YEAR columns using either strings or numbers. Values display as 1901 to 2155, and 0000. + * Protocol: FIELD_TYPE_YEAR = 13 + */ + YEAR("YEAR", Types.DATE, Date.class, 0, MysqlType.IS_NOT_DECIMAL, 4L, "[(4)]"), + /** + * [NATIONAL] VARCHAR(M) [CHARACTER SET charset_name] [COLLATE collation_name] + * A variable-length string. M represents the maximum column length in characters. The range of M is 0 to 65,535. + * The effective maximum length of a VARCHAR is subject to the maximum row size (65,535 bytes, which is shared among + * all columns) and the character set used. For example, utf8 characters can require up to three bytes per character, + * so a VARCHAR column that uses the utf8 character set can be declared to be a maximum of 21,844 characters. + * + * MySQL stores VARCHAR values as a 1-byte or 2-byte length prefix plus data. The length prefix indicates the number + * of bytes in the value. A VARCHAR column uses one length byte if values require no more than 255 bytes, two length + * bytes if values may require more than 255 bytes. + * + * Note + * MySQL 5.7 follows the standard SQL specification, and does not remove trailing spaces from VARCHAR values. + * + * VARCHAR is shorthand for CHARACTER VARYING. NATIONAL VARCHAR is the standard SQL way to define that a VARCHAR + * column should use some predefined character set. MySQL 4.1 and up uses utf8 as this predefined character set. + * NVARCHAR is shorthand for NATIONAL VARCHAR. + * + * Protocol: FIELD_TYPE_VARCHAR = 15 + * Protocol: FIELD_TYPE_VAR_STRING = 253 + */ + VARCHAR("VARCHAR", Types.VARCHAR, String.class, 0, MysqlType.IS_NOT_DECIMAL, 65535L, "(M) [CHARACTER SET charset_name] [COLLATE collation_name]"), + /** + * VARBINARY(M) + * The VARBINARY type is similar to the VARCHAR type, but stores binary byte strings rather than nonbinary + * character strings. M represents the maximum column length in bytes. + * + * Protocol: FIELD_TYPE_VARCHAR = 15 + * Protocol: FIELD_TYPE_VAR_STRING = 253 + */ + VARBINARY("VARBINARY", Types.VARBINARY, null, 0, MysqlType.IS_NOT_DECIMAL, 65535L, "(M)"), + /** + * BIT[(M)] + * A bit-field type. M indicates the number of bits per value, from 1 to 64. The default is 1 if M is omitted. + * Protocol: FIELD_TYPE_BIT = 16 + */ + BIT("BIT", Types.BIT, Boolean.class, 0, MysqlType.IS_DECIMAL, 1L, "[(M)]"), // TODO maybe precision=8 ? + /** + * The size of JSON documents stored in JSON columns is limited to the value of the max_allowed_packet system variable (max value 1073741824). + * (While the server manipulates a JSON value internally in memory, it can be larger; the limit applies when the server stores it.) + * + * Protocol: FIELD_TYPE_BIT = 245 + */ + JSON("JSON", Types.LONGVARCHAR, String.class, 0, MysqlType.IS_NOT_DECIMAL, 1073741824L, ""), + /** + * ENUM('value1','value2',...) [CHARACTER SET charset_name] [COLLATE collation_name] + * An enumeration. A string object that can have only one value, chosen from the list of values 'value1', + * 'value2', ..., NULL or the special '' error value. ENUM values are represented internally as integers. + * An ENUM column can have a maximum of 65,535 distinct elements. (The practical limit is less than 3000.) + * A table can have no more than 255 unique element list definitions among its ENUM and SET columns considered as a group + * + * Protocol: FIELD_TYPE_ENUM = 247 + */ + ENUM("ENUM", Types.CHAR, String.class, 0, MysqlType.IS_NOT_DECIMAL, 65535L, + "('value1','value2',...) [CHARACTER SET charset_name] [COLLATE collation_name]"), + /** + * SET('value1','value2',...) [CHARACTER SET charset_name] [COLLATE collation_name] + * A set. A string object that can have zero or more values, each of which must be chosen from the list + * of values 'value1', 'value2', ... SET values are represented internally as integers. + * A SET column can have a maximum of 64 distinct members. A table can have no more than 255 unique + * element list definitions among its ENUM and SET columns considered as a group + * + * Protocol: FIELD_TYPE_SET = 248 + */ + SET("SET", Types.CHAR, String.class, 0, MysqlType.IS_NOT_DECIMAL, 64L, "('value1','value2',...) [CHARACTER SET charset_name] [COLLATE collation_name]"), + /** + * TINYBLOB + * A BLOB column with a maximum length of 255 (28 - 1) bytes. Each TINYBLOB value is stored using a + * 1-byte length prefix that indicates the number of bytes in the value. + * + * Protocol:FIELD_TYPE_TINY_BLOB = 249 + */ + TINYBLOB("TINYBLOB", Types.VARBINARY, null, 0, MysqlType.IS_NOT_DECIMAL, 255L, ""), + /** + * TINYTEXT [CHARACTER SET charset_name] [COLLATE collation_name] + * A TEXT column with a maximum length of 255 (28 - 1) characters. The effective maximum length + * is less if the value contains multibyte characters. Each TINYTEXT value is stored using + * a 1-byte length prefix that indicates the number of bytes in the value. + * + * Protocol:FIELD_TYPE_TINY_BLOB = 249 + */ + TINYTEXT("TINYTEXT", Types.VARCHAR, String.class, 0, MysqlType.IS_NOT_DECIMAL, 255L, " [CHARACTER SET charset_name] [COLLATE collation_name]"), + /** + * MEDIUMBLOB + * A BLOB column with a maximum length of 16,777,215 (224 - 1) bytes. Each MEDIUMBLOB value is stored + * using a 3-byte length prefix that indicates the number of bytes in the value. + * + * Protocol: FIELD_TYPE_MEDIUM_BLOB = 250 + */ + MEDIUMBLOB("MEDIUMBLOB", Types.LONGVARBINARY, null, 0, MysqlType.IS_NOT_DECIMAL, 16777215L, ""), + /** + * MEDIUMTEXT [CHARACTER SET charset_name] [COLLATE collation_name] + * A TEXT column with a maximum length of 16,777,215 (224 - 1) characters. The effective maximum length + * is less if the value contains multibyte characters. Each MEDIUMTEXT value is stored using a 3-byte + * length prefix that indicates the number of bytes in the value. + * + * Protocol: FIELD_TYPE_MEDIUM_BLOB = 250 + */ + MEDIUMTEXT("MEDIUMTEXT", Types.LONGVARCHAR, String.class, 0, MysqlType.IS_NOT_DECIMAL, 16777215L, " [CHARACTER SET charset_name] [COLLATE collation_name]"), + /** + * LONGBLOB + * A BLOB column with a maximum length of 4,294,967,295 or 4GB (232 - 1) bytes. The effective maximum length + * of LONGBLOB columns depends on the configured maximum packet size in the client/server protocol and available + * memory. Each LONGBLOB value is stored using a 4-byte length prefix that indicates the number of bytes in the value. + * + * Protocol: FIELD_TYPE_LONG_BLOB = 251 + */ + LONGBLOB("LONGBLOB", Types.LONGVARBINARY, null, 0, MysqlType.IS_NOT_DECIMAL, 4294967295L, ""), + /** + * LONGTEXT [CHARACTER SET charset_name] [COLLATE collation_name] + * A TEXT column with a maximum length of 4,294,967,295 or 4GB (232 - 1) characters. The effective + * maximum length is less if the value contains multibyte characters. The effective maximum length + * of LONGTEXT columns also depends on the configured maximum packet size in the client/server protocol + * and available memory. Each LONGTEXT value is stored using a 4-byte length prefix that indicates + * the number of bytes in the value. + * + * Protocol: FIELD_TYPE_LONG_BLOB = 251 + */ + LONGTEXT("LONGTEXT", Types.LONGVARCHAR, String.class, 0, MysqlType.IS_NOT_DECIMAL, 4294967295L, " [CHARACTER SET charset_name] [COLLATE collation_name]"), + /** + * BLOB[(M)] + * A BLOB column with a maximum length of 65,535 (216 - 1) bytes. Each BLOB value is stored using + * a 2-byte length prefix that indicates the number of bytes in the value. + * An optional length M can be given for this type. If this is done, MySQL creates the column as + * the smallest BLOB type large enough to hold values M bytes long. + * + * Protocol: FIELD_TYPE_BLOB = 252 + */ + BLOB("BLOB", Types.LONGVARBINARY, null, 0, MysqlType.IS_NOT_DECIMAL, 65535L, "[(M)]"), + /** + * TEXT[(M)] [CHARACTER SET charset_name] [COLLATE collation_name] + * A TEXT column with a maximum length of 65,535 (216 - 1) characters. The effective maximum length + * is less if the value contains multibyte characters. Each TEXT value is stored using a 2-byte length + * prefix that indicates the number of bytes in the value. + * An optional length M can be given for this type. If this is done, MySQL creates the column as + * the smallest TEXT type large enough to hold values M characters long. + * + * Protocol: FIELD_TYPE_BLOB = 252 + */ + TEXT("TEXT", Types.LONGVARCHAR, String.class, 0, MysqlType.IS_NOT_DECIMAL, 65535L, "[(M)] [CHARACTER SET charset_name] [COLLATE collation_name]"), + /** + * [NATIONAL] CHAR[(M)] [CHARACTER SET charset_name] [COLLATE collation_name] + * A fixed-length string that is always right-padded with spaces to the specified length when stored. + * M represents the column length in characters. The range of M is 0 to 255. If M is omitted, the length is 1. + * Note + * Trailing spaces are removed when CHAR values are retrieved unless the PAD_CHAR_TO_FULL_LENGTH SQL mode is enabled. + * CHAR is shorthand for CHARACTER. NATIONAL CHAR (or its equivalent short form, NCHAR) is the standard SQL way + * to define that a CHAR column should use some predefined character set. MySQL 4.1 and up uses utf8 + * as this predefined character set. + * + * MySQL permits you to create a column of type CHAR(0). This is useful primarily when you have to be compliant + * with old applications that depend on the existence of a column but that do not actually use its value. + * CHAR(0) is also quite nice when you need a column that can take only two values: A column that is defined + * as CHAR(0) NULL occupies only one bit and can take only the values NULL and '' (the empty string). + * + * Protocol: FIELD_TYPE_STRING = 254 + */ + CHAR("CHAR", Types.CHAR, String.class, 0, MysqlType.IS_NOT_DECIMAL, 255L, "[(M)] [CHARACTER SET charset_name] [COLLATE collation_name]"), + /** + * BINARY(M) + * The BINARY type is similar to the CHAR type, but stores binary byte strings rather than nonbinary character strings. + * M represents the column length in bytes. + * + * The CHAR BYTE data type is an alias for the BINARY data type. + * + * Protocol: no concrete type on the wire TODO: really? + */ + BINARY("BINARY", Types.BINARY, null, 0, MysqlType.IS_NOT_DECIMAL, 255L, "(M)"), + /** + * Top class for Spatial Data Types + * + * Protocol: FIELD_TYPE_GEOMETRY = 255 + */ + GEOMETRY("GEOMETRY", Types.BINARY, null, 0, MysqlType.IS_NOT_DECIMAL, 65535L, ""), // TODO check precision, it isn't well documented, only mentioned that WKB format is represented by BLOB + /** + * Fall-back type for those MySQL data types which c/J can't recognize. + * Handled the same as BLOB. + * + * Has no protocol ID. + */ + UNKNOWN("UNKNOWN", Types.OTHER, null, 0, MysqlType.IS_NOT_DECIMAL, 65535L, ""); + + /** + * Get MysqlType matching the full MySQL type name, for example "DECIMAL(5,3) UNSIGNED ZEROFILL". + * Distinct *_UNSIGNED type will be returned if "UNSIGNED" is present in fullMysqlTypeName. + * + * @param fullMysqlTypeName + * full MySQL type name + * @return MysqlType + */ + public static MysqlType getByName(String fullMysqlTypeName) { + + // TODO parse complex names like [NATIONAL] VARCHAR(M) [CHARACTER SET charset_name] [COLLATE collation_name] + + String typeName = ""; + + if (fullMysqlTypeName.indexOf("(") != -1) { + typeName = fullMysqlTypeName.substring(0, fullMysqlTypeName.indexOf("(")).trim(); + } else { + typeName = fullMysqlTypeName; + } + + // the order of checks is important because some short names could match parts of longer names + if (StringUtils.indexOfIgnoreCase(typeName, "DECIMAL") != -1 || StringUtils.indexOfIgnoreCase(typeName, "DEC") != -1 + || StringUtils.indexOfIgnoreCase(typeName, "NUMERIC") != -1 || StringUtils.indexOfIgnoreCase(typeName, "FIXED") != -1) { + return StringUtils.indexOfIgnoreCase(fullMysqlTypeName, "UNSIGNED") != -1 ? DECIMAL_UNSIGNED : DECIMAL; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "TINYBLOB") != -1) { + // IMPORTANT: "TINYBLOB" must be checked before "TINY" + return TINYBLOB; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "TINYTEXT") != -1) { + // IMPORTANT: "TINYTEXT" must be checked before "TINY" + return TINYTEXT; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "TINYINT") != -1 || StringUtils.indexOfIgnoreCase(typeName, "TINY") != -1 + || StringUtils.indexOfIgnoreCase(typeName, "INT1") != -1) { + return StringUtils.indexOfIgnoreCase(fullMysqlTypeName, "UNSIGNED") != -1 || StringUtils.indexOfIgnoreCase(fullMysqlTypeName, "ZEROFILL") != -1 + ? TINYINT_UNSIGNED + : TINYINT; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "MEDIUMINT") != -1 + // IMPORTANT: "INT24" must be checked before "INT2" + || StringUtils.indexOfIgnoreCase(typeName, "INT24") != -1 || StringUtils.indexOfIgnoreCase(typeName, "INT3") != -1 + || StringUtils.indexOfIgnoreCase(typeName, "MIDDLEINT") != -1) { + return StringUtils.indexOfIgnoreCase(fullMysqlTypeName, "UNSIGNED") != -1 || StringUtils.indexOfIgnoreCase(fullMysqlTypeName, "ZEROFILL") != -1 + ? MEDIUMINT_UNSIGNED + : MEDIUMINT; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "SMALLINT") != -1 || StringUtils.indexOfIgnoreCase(typeName, "INT2") != -1) { + return StringUtils.indexOfIgnoreCase(fullMysqlTypeName, "UNSIGNED") != -1 || StringUtils.indexOfIgnoreCase(fullMysqlTypeName, "ZEROFILL") != -1 + ? SMALLINT_UNSIGNED + : SMALLINT; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "BIGINT") != -1 || StringUtils.indexOfIgnoreCase(typeName, "SERIAL") != -1 + || StringUtils.indexOfIgnoreCase(typeName, "INT8") != -1) { + // SERIAL is an alias for BIGINT UNSIGNED NOT NULL AUTO_INCREMENT UNIQUE. + return StringUtils.indexOfIgnoreCase(fullMysqlTypeName, "UNSIGNED") != -1 || StringUtils.indexOfIgnoreCase(fullMysqlTypeName, "ZEROFILL") != -1 + ? BIGINT_UNSIGNED + : BIGINT; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "POINT") != -1) { + // also covers "MULTIPOINT" + // IMPORTANT: "POINT" must be checked before "INT" + return GEOMETRY; // TODO think about different MysqlTypes for Spatial Data Types + + } else if (StringUtils.indexOfIgnoreCase(typeName, "INT") != -1 || StringUtils.indexOfIgnoreCase(typeName, "INTEGER") != -1 + || StringUtils.indexOfIgnoreCase(typeName, "INT4") != -1) { + // IMPORTANT: "INT" must be checked after all "*INT*" types + return StringUtils.indexOfIgnoreCase(fullMysqlTypeName, "UNSIGNED") != -1 || StringUtils.indexOfIgnoreCase(fullMysqlTypeName, "ZEROFILL") != -1 + ? INT_UNSIGNED + : INT; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "DOUBLE") != -1 || StringUtils.indexOfIgnoreCase(typeName, "REAL") != -1 + /* || StringUtils.indexOfIgnoreCase(name, "DOUBLE PRECISION") != -1 is caught by "DOUBLE" check */ + // IMPORTANT: "FLOAT8" must be checked before "FLOAT" + || StringUtils.indexOfIgnoreCase(typeName, "FLOAT8") != -1) { + // TODO Exception: If the REAL_AS_FLOAT SQL mode is enabled, REAL is a synonym for FLOAT rather than DOUBLE. + return StringUtils.indexOfIgnoreCase(fullMysqlTypeName, "UNSIGNED") != -1 || StringUtils.indexOfIgnoreCase(fullMysqlTypeName, "ZEROFILL") != -1 + ? DOUBLE_UNSIGNED + : DOUBLE; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "FLOAT") != -1 /* + * || StringUtils.indexOfIgnoreCase(name, "FLOAT4") != -1 is caught by + * "FLOAT" check + */) { + // TODO FLOAT(p) [UNSIGNED] [ZEROFILL]. If p is from 0 to 24, the data type becomes FLOAT with no M or D values. If p is from 25 to 53, the data type becomes DOUBLE with no M or D values. + return StringUtils.indexOfIgnoreCase(fullMysqlTypeName, "UNSIGNED") != -1 || StringUtils.indexOfIgnoreCase(fullMysqlTypeName, "ZEROFILL") != -1 + ? FLOAT_UNSIGNED + : FLOAT; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "NULL") != -1) { + return NULL; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "TIMESTAMP") != -1) { + // IMPORTANT: "TIMESTAMP" must be checked before "TIME" + return TIMESTAMP; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "DATETIME") != -1) { + // IMPORTANT: "DATETIME" must be checked before "DATE" and "TIME" + return DATETIME; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "DATE") != -1) { + return DATE; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "TIME") != -1) { + return TIME; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "YEAR") != -1) { + return YEAR; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "LONGBLOB") != -1) { + // IMPORTANT: "LONGBLOB" must be checked before "LONG" and "BLOB" + return LONGBLOB; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "LONGTEXT") != -1) { + // IMPORTANT: "LONGTEXT" must be checked before "LONG" and "TEXT" + return LONGTEXT; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "MEDIUMBLOB") != -1 || StringUtils.indexOfIgnoreCase(typeName, "LONG VARBINARY") != -1) { + // IMPORTANT: "MEDIUMBLOB" must be checked before "BLOB" + // IMPORTANT: "LONG VARBINARY" must be checked before "LONG" and "VARBINARY" + return MEDIUMBLOB; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "MEDIUMTEXT") != -1 || StringUtils.indexOfIgnoreCase(typeName, "LONG VARCHAR") != -1 + || StringUtils.indexOfIgnoreCase(typeName, "LONG") != -1) { + // IMPORTANT: "MEDIUMTEXT" must be checked before "TEXT" + // IMPORTANT: "LONG VARCHAR" must be checked before "VARCHAR" + return MEDIUMTEXT; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "VARCHAR") != -1 || StringUtils.indexOfIgnoreCase(typeName, "NVARCHAR") != -1 + || StringUtils.indexOfIgnoreCase(typeName, "NATIONAL VARCHAR") != -1 || StringUtils.indexOfIgnoreCase(typeName, "CHARACTER VARYING") != -1) { + // IMPORTANT: "CHARACTER VARYING" must be checked before "CHARACTER" and "CHAR" + return VARCHAR; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "VARBINARY") != -1) { + return VARBINARY; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "BINARY") != -1 || StringUtils.indexOfIgnoreCase(typeName, "CHAR BYTE") != -1) { + // IMPORTANT: "BINARY" must be checked after all "*BINARY" types + // IMPORTANT: "CHAR BYTE" must be checked before "CHAR" + return BINARY; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "LINESTRING") != -1) { + // also covers "MULTILINESTRING" + // IMPORTANT: "LINESTRING" must be checked before "STRING" + return GEOMETRY; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "STRING") != -1 + // IMPORTANT: "CHAR" must be checked after all "*CHAR*" types + || StringUtils.indexOfIgnoreCase(typeName, "CHAR") != -1 || StringUtils.indexOfIgnoreCase(typeName, "NCHAR") != -1 + || StringUtils.indexOfIgnoreCase(typeName, "NATIONAL CHAR") != -1 || StringUtils.indexOfIgnoreCase(typeName, "CHARACTER") != -1) { + return CHAR; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "BOOLEAN") != -1 || StringUtils.indexOfIgnoreCase(typeName, "BOOL") != -1) { + return BOOLEAN; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "BIT") != -1) { + return BIT; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "JSON") != -1) { + return JSON; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "ENUM") != -1) { + return ENUM; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "SET") != -1) { + return SET; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "BLOB") != -1) { + return BLOB; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "TEXT") != -1) { + return TEXT; + + } else if (StringUtils.indexOfIgnoreCase(typeName, "GEOM") != -1 // covers "GEOMETRY", "GEOMETRYCOLLECTION" and "GEOMCOLLECTION" + || StringUtils.indexOfIgnoreCase(typeName, "POINT") != -1 // also covers "MULTIPOINT" + || StringUtils.indexOfIgnoreCase(typeName, "POLYGON") != -1 // also covers "MULTIPOLYGON" + ) { + return GEOMETRY; // TODO think about different MysqlTypes for Spatial Data Types + + } + + return UNKNOWN; + } + + public static MysqlType getByJdbcType(int jdbcType) { + switch (jdbcType) { + case Types.BIGINT: + return BIGINT; + case Types.BINARY: + return BINARY; + case Types.BIT: + return BIT; + case Types.BOOLEAN: + return BOOLEAN; + case Types.CHAR: + case Types.NCHAR: // TODO check that it's correct + return CHAR; + case Types.DATE: + return DATE; + case Types.DECIMAL: + case Types.NUMERIC: + return DECIMAL; + case Types.DOUBLE: + case Types.FLOAT: + return DOUBLE; + case Types.INTEGER: + return INT; + case Types.LONGVARBINARY: + case Types.BLOB: // TODO check that it's correct + case Types.JAVA_OBJECT: // TODO check that it's correct + return BLOB; + case Types.LONGVARCHAR: + case Types.LONGNVARCHAR: // TODO check that it's correct + case Types.CLOB: // TODO check that it's correct + case Types.NCLOB: // TODO check that it's correct + return TEXT; + case Types.NULL: + return NULL; + case Types.REAL: + return FLOAT; + case Types.SMALLINT: + return SMALLINT; + case Types.TIME: + return TIME; + case Types.TIMESTAMP: + return TIMESTAMP; + case Types.TINYINT: + return TINYINT; + case Types.VARBINARY: + return VARBINARY; + case Types.VARCHAR: + case Types.NVARCHAR: // TODO check that it's correct + case Types.DATALINK: // TODO check that it's correct + case Types.SQLXML: // TODO check that it's correct + return VARCHAR; + + case Types.REF_CURSOR: + throw new FeatureNotAvailableException("REF_CURSOR type is not supported"); + case Types.TIME_WITH_TIMEZONE: + throw new FeatureNotAvailableException("TIME_WITH_TIMEZONE type is not supported"); + case Types.TIMESTAMP_WITH_TIMEZONE: + throw new FeatureNotAvailableException("TIMESTAMP_WITH_TIMEZONE type is not supported"); + + // TODO check next types + case Types.ARRAY: + case Types.DISTINCT: + case Types.OTHER: + case Types.REF: + case Types.ROWID: + case Types.STRUCT: + + default: + return UNKNOWN; + } + } + + /** + * Is CONVERT between the given SQL types supported? + * + * @param fromType + * the type to convert from + * @param toType + * the type to convert to + * @return true if so + * @see Types + */ + public static boolean supportsConvert(int fromType, int toType) { + + // TODO use MysqlTypes here ? + + switch (fromType) { + /* + * The char/binary types can be converted to pretty much anything. + */ + case java.sql.Types.CHAR: + case java.sql.Types.VARCHAR: + case java.sql.Types.LONGVARCHAR: + case java.sql.Types.BINARY: + case java.sql.Types.VARBINARY: + case java.sql.Types.LONGVARBINARY: + + switch (toType) { + case java.sql.Types.DECIMAL: + case java.sql.Types.NUMERIC: + case java.sql.Types.REAL: + case java.sql.Types.TINYINT: + case java.sql.Types.SMALLINT: + case java.sql.Types.INTEGER: + case java.sql.Types.BIGINT: + case java.sql.Types.FLOAT: + case java.sql.Types.DOUBLE: + case java.sql.Types.CHAR: + case java.sql.Types.VARCHAR: + case java.sql.Types.LONGVARCHAR: + case java.sql.Types.BINARY: + case java.sql.Types.VARBINARY: + case java.sql.Types.LONGVARBINARY: + case java.sql.Types.OTHER: + case java.sql.Types.DATE: + case java.sql.Types.TIME: + case java.sql.Types.TIMESTAMP: + return true; + + default: + return false; + } + + /* + * We don't handle the BIT type yet. + */ + case java.sql.Types.BIT: + return false; + + /* + * The numeric types. Basically they can convert among themselves, and with char/binary types. + */ + case java.sql.Types.DECIMAL: + case java.sql.Types.NUMERIC: + case java.sql.Types.REAL: + case java.sql.Types.TINYINT: + case java.sql.Types.SMALLINT: + case java.sql.Types.INTEGER: + case java.sql.Types.BIGINT: + case java.sql.Types.FLOAT: + case java.sql.Types.DOUBLE: + + switch (toType) { + case java.sql.Types.DECIMAL: + case java.sql.Types.NUMERIC: + case java.sql.Types.REAL: + case java.sql.Types.TINYINT: + case java.sql.Types.SMALLINT: + case java.sql.Types.INTEGER: + case java.sql.Types.BIGINT: + case java.sql.Types.FLOAT: + case java.sql.Types.DOUBLE: + case java.sql.Types.CHAR: + case java.sql.Types.VARCHAR: + case java.sql.Types.LONGVARCHAR: + case java.sql.Types.BINARY: + case java.sql.Types.VARBINARY: + case java.sql.Types.LONGVARBINARY: + return true; + + default: + return false; + } + + /* MySQL doesn't support a NULL type. */ + case java.sql.Types.NULL: + return false; + + /* + * With this driver, this will always be a serialized object, so the char/binary types will work. + */ + case java.sql.Types.OTHER: + + switch (toType) { + case java.sql.Types.CHAR: + case java.sql.Types.VARCHAR: + case java.sql.Types.LONGVARCHAR: + case java.sql.Types.BINARY: + case java.sql.Types.VARBINARY: + case java.sql.Types.LONGVARBINARY: + return true; + + default: + return false; + } + + /* Dates can be converted to char/binary types. */ + case java.sql.Types.DATE: + + switch (toType) { + case java.sql.Types.CHAR: + case java.sql.Types.VARCHAR: + case java.sql.Types.LONGVARCHAR: + case java.sql.Types.BINARY: + case java.sql.Types.VARBINARY: + case java.sql.Types.LONGVARBINARY: + return true; + + default: + return false; + } + + /* Time can be converted to char/binary types */ + case java.sql.Types.TIME: + + switch (toType) { + case java.sql.Types.CHAR: + case java.sql.Types.VARCHAR: + case java.sql.Types.LONGVARCHAR: + case java.sql.Types.BINARY: + case java.sql.Types.VARBINARY: + case java.sql.Types.LONGVARBINARY: + return true; + + default: + return false; + } + + /* + * Timestamp can be converted to char/binary types and date/time types (with loss of precision). + */ + case java.sql.Types.TIMESTAMP: + + switch (toType) { + case java.sql.Types.CHAR: + case java.sql.Types.VARCHAR: + case java.sql.Types.LONGVARCHAR: + case java.sql.Types.BINARY: + case java.sql.Types.VARBINARY: + case java.sql.Types.LONGVARBINARY: + case java.sql.Types.TIME: + case java.sql.Types.DATE: + return true; + + default: + return false; + } + + /* We shouldn't get here! */ + default: + return false; // not sure + } + } + + public static boolean isSigned(MysqlType type) { + switch (type) { + case DECIMAL: + case TINYINT: + case SMALLINT: + case INT: + case BIGINT: + case MEDIUMINT: + case FLOAT: + case DOUBLE: + return true; + default: + return false; + } + } + + private final String name; + protected int jdbcType; + protected final Class javaClass; + private final int flagsMask; + private final boolean isDecimal; + private final Long precision; + private final String createParams; + + /** + * + * @param mysqlTypeName + * mysqlTypeName + * @param jdbcType + * jdbcType + * @param javaClass + * javaClass + * @param allowedFlags + * allowedFlags + * @param isDec + * isDec + * @param precision + * represents the maximum column size that the server supports for the given datatype. + *
    + *
  • For numeric data, this is the maximum precision. + *
  • + * For character data, this is the length in characters. + *
  • For datetime datatypes, this is the length in characters of the String + * representation (assuming the maximum allowed precision of the fractional seconds component). + *
  • For binary data, this is the length in bytes. + *
  • For the ROWID datatype, this is the length in bytes. + *
  • Null is returned for data types where the column size is not applicable. + *
+ * @param createParams + * params + */ + private MysqlType(String mysqlTypeName, int jdbcType, Class javaClass, int allowedFlags, boolean isDec, Long precision, String createParams) { + this.name = mysqlTypeName; + this.jdbcType = jdbcType; + this.javaClass = javaClass; + this.flagsMask = allowedFlags; + this.isDecimal = isDec; + this.precision = precision; + this.createParams = createParams; + } + + public String getName() { + return this.name; + } + + public int getJdbcType() { + return this.jdbcType; + } + + public boolean isAllowed(int flag) { + return ((this.flagsMask & flag) > 0); + } + + public String getClassName() { + if (this.javaClass == null) { + return "[B"; + } + return this.javaClass.getName(); + } + + /** + * Checks if the MySQL Type is a Decimal/Number Type + * + * @return true if the MySQL Type is a Decimal/Number Type + */ + public boolean isDecimal() { + return this.isDecimal; + } + + /** + * The PRECISION column represents the maximum column size that the server supports for the given datatype. + *
    + *
  • For numeric data, this is the maximum + * precision. + *
  • For character data, this is the length in characters. + *
  • For datetime datatypes, this is the length in characters of the String + * representation (assuming the maximum allowed precision of the fractional seconds component). + *
  • For binary data, this is the length in bytes. + *
  • For + * the ROWID datatype, this is the length in bytes. + *
  • Null is returned for data types where the column size is not applicable. + *
+ * + * @return precision + */ + public Long getPrecision() { + return this.precision; + } + + public String getCreateParams() { + return this.createParams; + } + + public static final int FIELD_FLAG_NOT_NULL = 1; + public static final int FIELD_FLAG_PRIMARY_KEY = 2; + public static final int FIELD_FLAG_UNIQUE_KEY = 4; + public static final int FIELD_FLAG_MULTIPLE_KEY = 8; + public static final int FIELD_FLAG_BLOB = 16; + public static final int FIELD_FLAG_UNSIGNED = 32; + public static final int FIELD_FLAG_ZEROFILL = 64; + public static final int FIELD_FLAG_BINARY = 128; + public static final int FIELD_FLAG_AUTO_INCREMENT = 512; + + private static final boolean IS_DECIMAL = true; + private static final boolean IS_NOT_DECIMAL = false; + + @Override + public String getVendor() { + return "com.mysql.cj"; + } + + @Override + public Integer getVendorTypeNumber() { + return this.jdbcType; + } + + // Protocol field type numbers + public static final int FIELD_TYPE_DECIMAL = 0; + public static final int FIELD_TYPE_TINY = 1; + public static final int FIELD_TYPE_SHORT = 2; + public static final int FIELD_TYPE_LONG = 3; + public static final int FIELD_TYPE_FLOAT = 4; + public static final int FIELD_TYPE_DOUBLE = 5; + public static final int FIELD_TYPE_NULL = 6; + public static final int FIELD_TYPE_TIMESTAMP = 7; + public static final int FIELD_TYPE_LONGLONG = 8; + public static final int FIELD_TYPE_INT24 = 9; + public static final int FIELD_TYPE_DATE = 10; + public static final int FIELD_TYPE_TIME = 11; + public static final int FIELD_TYPE_DATETIME = 12; + public static final int FIELD_TYPE_YEAR = 13; + public static final int FIELD_TYPE_VARCHAR = 15; + public static final int FIELD_TYPE_BIT = 16; + public static final int FIELD_TYPE_JSON = 245; + public static final int FIELD_TYPE_NEWDECIMAL = 246; + public static final int FIELD_TYPE_ENUM = 247; + public static final int FIELD_TYPE_SET = 248; + public static final int FIELD_TYPE_TINY_BLOB = 249; + public static final int FIELD_TYPE_MEDIUM_BLOB = 250; + public static final int FIELD_TYPE_LONG_BLOB = 251; + public static final int FIELD_TYPE_BLOB = 252; + public static final int FIELD_TYPE_VAR_STRING = 253; + public static final int FIELD_TYPE_STRING = 254; + public static final int FIELD_TYPE_GEOMETRY = 255; + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/ParseInfo.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/ParseInfo.java new file mode 100644 index 0000000..34df870 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/ParseInfo.java @@ -0,0 +1,596 @@ +/* + * Copyright (c) 2017, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.io.UnsupportedEncodingException; +import java.util.ArrayList; + +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.WrongArgumentException; +import com.mysql.cj.util.StringUtils; + +/** + * Represents the "parsed" state of a prepared query, with the statement broken up into its static and dynamic (where parameters are bound) parts. + */ +public class ParseInfo { + + protected static final String[] ON_DUPLICATE_KEY_UPDATE_CLAUSE = new String[] { "ON", "DUPLICATE", "KEY", "UPDATE" }; + + private char firstStmtChar = 0; + + private boolean foundLoadData = false; + + long lastUsed = 0; + + int statementLength = 0; + + int statementStartPos = 0; + + boolean canRewriteAsMultiValueInsert = false; + + byte[][] staticSql = null; + + boolean hasPlaceholders = false; + + public int numberOfQueries = 1; + + boolean isOnDuplicateKeyUpdate = false; + + int locationOfOnDuplicateKeyUpdate = -1; + + String valuesClause; + + boolean parametersInDuplicateKeyClause = false; + + String charEncoding; + + private ParseInfo batchHead; + + private ParseInfo batchValues; + + private ParseInfo batchODKUClause; + + private ParseInfo(byte[][] staticSql, char firstStmtChar, boolean foundLoadData, boolean isOnDuplicateKeyUpdate, int locationOfOnDuplicateKeyUpdate, + int statementLength, int statementStartPos) { + this.firstStmtChar = firstStmtChar; + this.foundLoadData = foundLoadData; + this.isOnDuplicateKeyUpdate = isOnDuplicateKeyUpdate; + this.locationOfOnDuplicateKeyUpdate = locationOfOnDuplicateKeyUpdate; + this.statementLength = statementLength; + this.statementStartPos = statementStartPos; + this.staticSql = staticSql; + } + + public ParseInfo(String sql, Session session, String encoding) { + this(sql, session, encoding, true); + } + + public ParseInfo(String sql, Session session, String encoding, boolean buildRewriteInfo) { + + try { + if (sql == null) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("PreparedStatement.61"), + session.getExceptionInterceptor()); + } + + this.charEncoding = encoding; + this.lastUsed = System.currentTimeMillis(); + + String quotedIdentifierString = session.getIdentifierQuoteString(); + + char quotedIdentifierChar = 0; + + if ((quotedIdentifierString != null) && !quotedIdentifierString.equals(" ") && (quotedIdentifierString.length() > 0)) { + quotedIdentifierChar = quotedIdentifierString.charAt(0); + } + + this.statementLength = sql.length(); + + ArrayList endpointList = new ArrayList<>(); + boolean inQuotes = false; + char quoteChar = 0; + boolean inQuotedId = false; + int lastParmEnd = 0; + int i; + + boolean noBackslashEscapes = session.getServerSession().isNoBackslashEscapesSet(); + + // we're not trying to be real pedantic here, but we'd like to skip comments at the beginning of statements, as frameworks such as Hibernate + // use them to aid in debugging + + this.statementStartPos = findStartOfStatement(sql); + + for (i = this.statementStartPos; i < this.statementLength; ++i) { + char c = sql.charAt(i); + + if ((this.firstStmtChar == 0) && Character.isLetter(c)) { + // Determine what kind of statement we're doing (_S_elect, _I_nsert, etc.) + this.firstStmtChar = Character.toUpperCase(c); + + // no need to search for "ON DUPLICATE KEY UPDATE" if not an INSERT statement + if (this.firstStmtChar == 'I') { + this.locationOfOnDuplicateKeyUpdate = getOnDuplicateKeyLocation(sql, + session.getPropertySet().getBooleanProperty(PropertyKey.dontCheckOnDuplicateKeyUpdateInSQL).getValue(), + session.getPropertySet().getBooleanProperty(PropertyKey.rewriteBatchedStatements).getValue(), + session.getServerSession().isNoBackslashEscapesSet()); + this.isOnDuplicateKeyUpdate = this.locationOfOnDuplicateKeyUpdate != -1; + } + } + + if (!noBackslashEscapes && c == '\\' && i < (this.statementLength - 1)) { + i++; + continue; // next character is escaped + } + + // are we in a quoted identifier? (only valid when the id is not inside a 'string') + if (!inQuotes && (quotedIdentifierChar != 0) && (c == quotedIdentifierChar)) { + inQuotedId = !inQuotedId; + } else if (!inQuotedId) { + // only respect quotes when not in a quoted identifier + + if (inQuotes) { + if (((c == '\'') || (c == '"')) && c == quoteChar) { + if (i < (this.statementLength - 1) && sql.charAt(i + 1) == quoteChar) { + i++; + continue; // inline quote escape + } + + inQuotes = !inQuotes; + quoteChar = 0; + } else if (((c == '\'') || (c == '"')) && c == quoteChar) { + inQuotes = !inQuotes; + quoteChar = 0; + } + } else { + if (c == '#' || (c == '-' && (i + 1) < this.statementLength && sql.charAt(i + 1) == '-')) { + // run out to end of statement, or newline, whichever comes first + int endOfStmt = this.statementLength - 1; + + for (; i < endOfStmt; i++) { + c = sql.charAt(i); + + if (c == '\r' || c == '\n') { + break; + } + } + + continue; + } else if (c == '/' && (i + 1) < this.statementLength) { + // Comment? + char cNext = sql.charAt(i + 1); + + if (cNext == '*') { + i += 2; + + for (int j = i; j < this.statementLength; j++) { + i++; + cNext = sql.charAt(j); + + if (cNext == '*' && (j + 1) < this.statementLength) { + if (sql.charAt(j + 1) == '/') { + i++; + + if (i < this.statementLength) { + c = sql.charAt(i); + } + + break; // comment done + } + } + } + } + } else if ((c == '\'') || (c == '"')) { + inQuotes = true; + quoteChar = c; + } + } + } + + if (!inQuotes && !inQuotedId) { + if ((c == '?')) { + endpointList.add(new int[] { lastParmEnd, i }); + lastParmEnd = i + 1; + + if (this.isOnDuplicateKeyUpdate && i > this.locationOfOnDuplicateKeyUpdate) { + this.parametersInDuplicateKeyClause = true; + } + } else if (c == ';') { + int j = i + 1; + if (j < this.statementLength) { + for (; j < this.statementLength; j++) { + if (!Character.isWhitespace(sql.charAt(j))) { + break; + } + } + if (j < this.statementLength) { + this.numberOfQueries++; + } + i = j - 1; + } + } + } + } + + if (this.firstStmtChar == 'L') { + if (StringUtils.startsWithIgnoreCaseAndWs(sql, "LOAD DATA")) { + this.foundLoadData = true; + } else { + this.foundLoadData = false; + } + } else { + this.foundLoadData = false; + } + + endpointList.add(new int[] { lastParmEnd, this.statementLength }); + this.staticSql = new byte[endpointList.size()][]; + this.hasPlaceholders = this.staticSql.length > 1; + + for (i = 0; i < this.staticSql.length; i++) { + int[] ep = endpointList.get(i); + int end = ep[1]; + int begin = ep[0]; + int len = end - begin; + + if (this.foundLoadData) { + this.staticSql[i] = StringUtils.getBytes(sql, begin, len); + } else if (encoding == null) { + byte[] buf = new byte[len]; + + for (int j = 0; j < len; j++) { + buf[j] = (byte) sql.charAt(begin + j); + } + + this.staticSql[i] = buf; + } else { + this.staticSql[i] = StringUtils.getBytes(sql, begin, len, encoding); + } + } + } catch (StringIndexOutOfBoundsException oobEx) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("PreparedStatement.62", new Object[] { sql }), oobEx, + session.getExceptionInterceptor()); + } + + if (buildRewriteInfo) { + this.canRewriteAsMultiValueInsert = this.numberOfQueries == 1 && !this.parametersInDuplicateKeyClause + && canRewrite(sql, this.isOnDuplicateKeyUpdate, this.locationOfOnDuplicateKeyUpdate, this.statementStartPos); + if (this.canRewriteAsMultiValueInsert && session.getPropertySet().getBooleanProperty(PropertyKey.rewriteBatchedStatements).getValue()) { + buildRewriteBatchedParams(sql, session, encoding); + } + } + + } + + public byte[][] getStaticSql() { + return this.staticSql; + } + + public String getValuesClause() { + return this.valuesClause; + } + + public int getLocationOfOnDuplicateKeyUpdate() { + return this.locationOfOnDuplicateKeyUpdate; + } + + public boolean canRewriteAsMultiValueInsertAtSqlLevel() { + return this.canRewriteAsMultiValueInsert; + } + + public boolean containsOnDuplicateKeyUpdateInSQL() { + return this.isOnDuplicateKeyUpdate; + } + + private void buildRewriteBatchedParams(String sql, Session session, String encoding) { + this.valuesClause = extractValuesClause(sql, session.getIdentifierQuoteString()); + String odkuClause = this.isOnDuplicateKeyUpdate ? sql.substring(this.locationOfOnDuplicateKeyUpdate) : null; + + String headSql = null; + + if (this.isOnDuplicateKeyUpdate) { + headSql = sql.substring(0, this.locationOfOnDuplicateKeyUpdate); + } else { + headSql = sql; + } + + this.batchHead = new ParseInfo(headSql, session, encoding, false); + this.batchValues = new ParseInfo("," + this.valuesClause, session, encoding, false); + this.batchODKUClause = null; + + if (odkuClause != null && odkuClause.length() > 0) { + this.batchODKUClause = new ParseInfo("," + this.valuesClause + " " + odkuClause, session, encoding, false); + } + } + + private String extractValuesClause(String sql, String quoteCharStr) { + int indexOfValues = -1; + int valuesSearchStart = this.statementStartPos; + + while (indexOfValues == -1) { + if (quoteCharStr.length() > 0) { + indexOfValues = StringUtils.indexOfIgnoreCase(valuesSearchStart, sql, "VALUES", quoteCharStr, quoteCharStr, + StringUtils.SEARCH_MODE__MRK_COM_WS); + } else { + indexOfValues = StringUtils.indexOfIgnoreCase(valuesSearchStart, sql, "VALUES"); + } + + if (indexOfValues > 0) { + /* check if the char immediately preceding VALUES may be part of the table name */ + char c = sql.charAt(indexOfValues - 1); + if (!(Character.isWhitespace(c) || c == ')' || c == '`')) { + valuesSearchStart = indexOfValues + 6; + indexOfValues = -1; + } else { + /* check if the char immediately following VALUES may be whitespace or open parenthesis */ + c = sql.charAt(indexOfValues + 6); + if (!(Character.isWhitespace(c) || c == '(')) { + valuesSearchStart = indexOfValues + 6; + indexOfValues = -1; + } + } + } else { + break; + } + } + + if (indexOfValues == -1) { + return null; + } + + int indexOfFirstParen = sql.indexOf('(', indexOfValues + 6); + + if (indexOfFirstParen == -1) { + return null; + } + + int endOfValuesClause = this.isOnDuplicateKeyUpdate ? this.locationOfOnDuplicateKeyUpdate : sql.length(); + + return sql.substring(indexOfFirstParen, endOfValuesClause); + } + + /** + * Returns a ParseInfo for a multi-value INSERT for a batch of size numBatch (without parsing!). + * + * @param numBatch + * number of batched parameters + * @return {@link ParseInfo} + */ + public synchronized ParseInfo getParseInfoForBatch(int numBatch) { + AppendingBatchVisitor apv = new AppendingBatchVisitor(); + buildInfoForBatch(numBatch, apv); + + ParseInfo batchParseInfo = new ParseInfo(apv.getStaticSqlStrings(), this.firstStmtChar, this.foundLoadData, this.isOnDuplicateKeyUpdate, + this.locationOfOnDuplicateKeyUpdate, this.statementLength, this.statementStartPos); + + return batchParseInfo; + } + + /** + * Returns a preparable SQL string for the number of batched parameters; used by server-side prepared statements + * when re-writing batch INSERTs. + * + * @param numBatch + * number of batched parameters + * @return SQL string + * @throws UnsupportedEncodingException + * if an error occurs + */ + public String getSqlForBatch(int numBatch) throws UnsupportedEncodingException { + ParseInfo batchInfo = getParseInfoForBatch(numBatch); + + return batchInfo.getSqlForBatch(); + } + + /** + * Used for filling in the SQL for getPreparedSql() - for debugging + * + * @return sql string + * @throws UnsupportedEncodingException + * if an error occurs + */ + public String getSqlForBatch() throws UnsupportedEncodingException { + int size = 0; + final byte[][] sqlStrings = this.staticSql; + final int sqlStringsLength = sqlStrings.length; + + for (int i = 0; i < sqlStringsLength; i++) { + size += sqlStrings[i].length; + size++; // for the '?' + } + + StringBuilder buf = new StringBuilder(size); + + for (int i = 0; i < sqlStringsLength - 1; i++) { + buf.append(StringUtils.toString(sqlStrings[i], this.charEncoding)); + buf.append("?"); + } + + buf.append(StringUtils.toString(sqlStrings[sqlStringsLength - 1])); + + return buf.toString(); + } + + /** + * Builds a ParseInfo for the given batch size, without parsing. We use + * a visitor pattern here, because the if {}s make computing a size for the + * resultant byte[][] make this too complex, and we don't necessarily want to + * use a List for this, because the size can be dynamic, and thus we'll not be + * able to guess a good initial size for an array-based list, and it's not + * efficient to convert a LinkedList to an array. + * + * @param numBatch + * number of batched parameters + * @param visitor + * visitor + */ + private void buildInfoForBatch(int numBatch, BatchVisitor visitor) { + if (!this.hasPlaceholders) { + if (numBatch == 1) { + // ParseInfo for a multi-value INSERT that doesn't have any placeholder may require two or more batches (depends on if ODKU is present or not). + // The original sql should be able to handle it. + visitor.append(this.staticSql[0]); + + return; + } + + // Without placeholders, only the values segment of the query needs repeating. + + final byte[] headStaticSql = this.batchHead.staticSql[0]; + visitor.append(headStaticSql).increment(); + + int numValueRepeats = numBatch - 1; // First one is in the "head". + if (this.batchODKUClause != null) { + numValueRepeats--; // Last one is in the ODKU clause. + } + + final byte[] valuesStaticSql = this.batchValues.staticSql[0]; + for (int i = 0; i < numValueRepeats; i++) { + visitor.mergeWithLast(valuesStaticSql).increment(); + } + + if (this.batchODKUClause != null) { + final byte[] batchOdkuStaticSql = this.batchODKUClause.staticSql[0]; + visitor.mergeWithLast(batchOdkuStaticSql).increment(); + } + + return; + } + + // Placeholders require assembling all the parts in each segment of the query and repeat them as needed. + + // Add the head section except the last part. + final byte[][] headStaticSql = this.batchHead.staticSql; + final int headStaticSqlLength = headStaticSql.length; + byte[] endOfHead = headStaticSql[headStaticSqlLength - 1]; + + for (int i = 0; i < headStaticSqlLength - 1; i++) { + visitor.append(headStaticSql[i]).increment(); + } + + // Repeat the values section as many times as needed. + int numValueRepeats = numBatch - 1; // First one is in the "head". + if (this.batchODKUClause != null) { + numValueRepeats--; // Last one is in the ODKU clause. + } + + final byte[][] valuesStaticSql = this.batchValues.staticSql; + final int valuesStaticSqlLength = valuesStaticSql.length; + byte[] beginOfValues = valuesStaticSql[0]; + byte[] endOfValues = valuesStaticSql[valuesStaticSqlLength - 1]; + + for (int i = 0; i < numValueRepeats; i++) { + visitor.merge(endOfValues, beginOfValues).increment(); + for (int j = 1; j < valuesStaticSqlLength - 1; j++) { + visitor.append(valuesStaticSql[j]).increment(); + } + } + + // Append the last value and/or ending. + if (this.batchODKUClause != null) { + final byte[][] batchOdkuStaticSql = this.batchODKUClause.staticSql; + final int batchOdkuStaticSqlLength = batchOdkuStaticSql.length; + byte[] beginOfOdku = batchOdkuStaticSql[0]; + byte[] endOfOdku = batchOdkuStaticSql[batchOdkuStaticSqlLength - 1]; + + if (numBatch > 1) { + visitor.merge(numValueRepeats > 0 ? endOfValues : endOfHead, beginOfOdku).increment(); + for (int i = 1; i < batchOdkuStaticSqlLength; i++) { + visitor.append(batchOdkuStaticSql[i]).increment(); + } + } else { + visitor.append(endOfOdku).increment(); + } + } else { + visitor.append(endOfHead); + } + } + + protected static int findStartOfStatement(String sql) { + int statementStartPos = 0; + + if (StringUtils.startsWithIgnoreCaseAndWs(sql, "/*")) { + statementStartPos = sql.indexOf("*/"); + + if (statementStartPos == -1) { + statementStartPos = 0; + } else { + statementStartPos += 2; + } + } else if (StringUtils.startsWithIgnoreCaseAndWs(sql, "--") || StringUtils.startsWithIgnoreCaseAndWs(sql, "#")) { + statementStartPos = sql.indexOf('\n'); + + if (statementStartPos == -1) { + statementStartPos = sql.indexOf('\r'); + + if (statementStartPos == -1) { + statementStartPos = 0; + } + } + } + + return statementStartPos; + } + + public static int getOnDuplicateKeyLocation(String sql, boolean dontCheckOnDuplicateKeyUpdateInSQL, boolean rewriteBatchedStatements, + boolean noBackslashEscapes) { + return dontCheckOnDuplicateKeyUpdateInSQL && !rewriteBatchedStatements ? -1 : StringUtils.indexOfIgnoreCase(0, sql, ON_DUPLICATE_KEY_UPDATE_CLAUSE, + "\"'`", "\"'`", noBackslashEscapes ? StringUtils.SEARCH_MODE__MRK_COM_WS : StringUtils.SEARCH_MODE__ALL); + } + + protected static boolean canRewrite(String sql, boolean isOnDuplicateKeyUpdate, int locationOfOnDuplicateKeyUpdate, int statementStartPos) { + // Needs to be INSERT or REPLACE. + // Can't have INSERT ... SELECT or INSERT ... ON DUPLICATE KEY UPDATE with an id=LAST_INSERT_ID(...). + + if (StringUtils.startsWithIgnoreCaseAndWs(sql, "INSERT", statementStartPos)) { + if (StringUtils.indexOfIgnoreCase(statementStartPos, sql, "SELECT", "\"'`", "\"'`", StringUtils.SEARCH_MODE__MRK_COM_WS) != -1) { + return false; + } + if (isOnDuplicateKeyUpdate) { + int updateClausePos = StringUtils.indexOfIgnoreCase(locationOfOnDuplicateKeyUpdate, sql, " UPDATE "); + if (updateClausePos != -1) { + return StringUtils.indexOfIgnoreCase(updateClausePos, sql, "LAST_INSERT_ID", "\"'`", "\"'`", StringUtils.SEARCH_MODE__MRK_COM_WS) == -1; + } + } + return true; + } + + return StringUtils.startsWithIgnoreCaseAndWs(sql, "REPLACE", statementStartPos) + && StringUtils.indexOfIgnoreCase(statementStartPos, sql, "SELECT", "\"'`", "\"'`", StringUtils.SEARCH_MODE__MRK_COM_WS) == -1; + } + + public boolean isFoundLoadData() { + return this.foundLoadData; + } + + public char getFirstStmtChar() { + return this.firstStmtChar; + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/PerConnectionLRUFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/PerConnectionLRUFactory.java new file mode 100644 index 0000000..41a8fda --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/PerConnectionLRUFactory.java @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2012, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.util.Set; + +import com.mysql.cj.util.LRUCache; + +public class PerConnectionLRUFactory implements CacheAdapterFactory { + + public CacheAdapter getInstance(Object syncMutex, String url, int cacheMaxSize, int maxKeySize) { + + return new PerConnectionLRU(syncMutex, cacheMaxSize, maxKeySize); + } + + class PerConnectionLRU implements CacheAdapter { + private final int cacheSqlLimit; + private final LRUCache cache; + private final Object syncMutex; + + protected PerConnectionLRU(Object syncMutex, int cacheMaxSize, int maxKeySize) { + final int cacheSize = cacheMaxSize; + this.cacheSqlLimit = maxKeySize; + this.cache = new LRUCache<>(cacheSize); + this.syncMutex = syncMutex; + } + + public ParseInfo get(String key) { + if (key == null || key.length() > this.cacheSqlLimit) { + return null; + } + + synchronized (this.syncMutex) { + return this.cache.get(key); + } + } + + public void put(String key, ParseInfo value) { + if (key == null || key.length() > this.cacheSqlLimit) { + return; + } + + synchronized (this.syncMutex) { + this.cache.put(key, value); + } + } + + public void invalidate(String key) { + synchronized (this.syncMutex) { + this.cache.remove(key); + } + } + + public void invalidateAll(Set keys) { + synchronized (this.syncMutex) { + for (String key : keys) { + this.cache.remove(key); + } + } + + } + + public void invalidateAll() { + synchronized (this.syncMutex) { + this.cache.clear(); + } + } + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/PingTarget.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/PingTarget.java new file mode 100644 index 0000000..bfd597d --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/PingTarget.java @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2007, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +public interface PingTarget { + + void doPing() throws Exception; + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/PreparedQuery.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/PreparedQuery.java new file mode 100644 index 0000000..9945c81 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/PreparedQuery.java @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2017, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import com.mysql.cj.protocol.Message; + +public interface PreparedQuery> extends Query { + + ParseInfo getParseInfo(); + + void setParseInfo(ParseInfo parseInfo); + + void checkNullOrEmptyQuery(String sql); + + String getOriginalSql(); + + void setOriginalSql(String originalSql); + + int getParameterCount(); + + void setParameterCount(int parameterCount); + + public T getQueryBindings(); + + public void setQueryBindings(T queryBindings); + + int computeBatchSize(int numBatchedArgs); + + int getBatchCommandIndex(); + + void setBatchCommandIndex(int batchCommandIndex); + + String asSql(); + + String asSql(boolean quoteStreamsAndUnknowns); + + M fillSendPacket(); + + M fillSendPacket(QueryBindings bindings); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/Query.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/Query.java new file mode 100644 index 0000000..6e1f1a1 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/Query.java @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2017, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.util.List; +import java.util.concurrent.atomic.AtomicBoolean; + +import com.mysql.cj.protocol.Message; +import com.mysql.cj.protocol.ProtocolEntityFactory; +import com.mysql.cj.protocol.Resultset; + +public interface Query { + + public enum CancelStatus { + NOT_CANCELED, CANCELED_BY_USER, CANCELED_BY_TIMEOUT; + } + + /** + * Returns the query id used when profiling + * + * @return id + */ + int getId(); + + void setCancelStatus(CancelStatus cs); + + void checkCancelTimeout(); + + ProtocolEntityFactory getResultSetFactory(); + + Session getSession(); + + Object getCancelTimeoutMutex(); + + void resetCancelledState(); + + void closeQuery(); + + void addBatch(Object batch); + + /** + * Get the batched args as added by the addBatch method(s). + * The list is unmodifiable and might contain any combination of String, + * ClientPreparedQueryBindings, or ServerPreparedQueryBindings depending on how the parameters were + * batched. + * + * @return an unmodifiable List of batched args + */ + List getBatchedArgs(); + + void clearBatchedArgs(); + + QueryAttributesBindings getQueryAttributesBindings(); + + int getResultFetchSize(); + + void setResultFetchSize(int fetchSize); + + Resultset.Type getResultType(); + + void setResultType(Resultset.Type resultSetType); + + int getTimeoutInMillis(); + + void setTimeoutInMillis(int timeoutInMillis); + + void setExecuteTime(long executeTime); + + /** + * Returns the elapsed time for the server to execute the query. + * + * @return the time it took for the server to execute the query. + */ + long getExecuteTime(); + + CancelQueryTask startQueryTimer(Query stmtToCancel, int timeout); + + AtomicBoolean getStatementExecuting(); + + String getCurrentDatabase(); + + void setCurrentDatabase(String currentDb); + + boolean isClearWarningsCalled(); + + void setClearWarningsCalled(boolean clearWarningsCalled); + + void statementBegins(); + + void stopQueryTimer(CancelQueryTask timeoutTask, boolean rethrowCancelReason, boolean checkCancelTimeout); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/QueryAttributesBindValue.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/QueryAttributesBindValue.java new file mode 100644 index 0000000..505bfb4 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/QueryAttributesBindValue.java @@ -0,0 +1,76 @@ +/* + * Copyright (c) 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +/** + * An internal representation of a query attribute bind value. + * + */ +public interface QueryAttributesBindValue { + /** + * Checks whether this query attribute is the null value. + * + * @return + * true if this query attribute value is null. + */ + boolean isNull(); + + /** + * Gets the name of this query attribute. + * + * @return + * the name of this query attribute. + */ + String getName(); + + /** + * Gets the type of this query attribute. Query attributes types are one of the {@link MysqlType}.FIELD_TYPE_*. + * + * @return + * the type of this query attribute. + */ + int getType(); + + /** + * Gets the value of this query attribute. + * + * @return + * the value of this query attribute. + */ + Object getValue(); + + /** + * Gets the length of this query attribute. + * + * @return + * the expected length, in Bytes, of this query attribute value after being encoded. + */ + long getBoundLength(); +} \ No newline at end of file diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/QueryAttributesBindings.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/QueryAttributesBindings.java new file mode 100644 index 0000000..cc1f8fb --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/QueryAttributesBindings.java @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.sql.Statement; +import java.util.function.Consumer; + +/** + * Instances of this interface keep the list of query attributes assigned to a {@link Statement} object. + */ +public interface QueryAttributesBindings { + /** + * Adds a new query attribute to the list of query attributes. Implementations must validate the type of the given the object and reject it or replace it by + * another representation if not supported, by its String version, for example. Query attribute names are not checked for duplication. + * + * @param name + * the query attribute name. + * + * @param value + * the query attribute value. + */ + void setAttribute(String name, Object value); + + /** + * Get the count of query attributes in the list. + * + * @return + * the number of query attributes existing in the list. + */ + int getCount(); + + /** + * Returns an internal representation of the query attribute in the given position of the query attributes list. It's implementation dependent what to do + * when the index value is invalid. + * + * @param index + * the position of the query attribute value to return. + * + * @return + * the {@link QueryAttributesBindValue} in the given position of the query attributes list. + */ + QueryAttributesBindValue getAttributeValue(int index); + + /** + * Runs through all query attributes while feeding the given {@link Consumer} with each one of them. + * + * @param bindAttribute + * A {@link Consumer} for each one of the single query attributes. + */ + void runThroughAll(Consumer bindAttribute); + + /** + * Removes all query attributes from the query attributes list. + */ + void clearAttributes(); +} \ No newline at end of file diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/QueryBindings.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/QueryBindings.java new file mode 100644 index 0000000..c7800f9 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/QueryBindings.java @@ -0,0 +1,239 @@ +/* + * Copyright (c) 2017, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.io.InputStream; +import java.io.Reader; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.sql.Clob; +import java.sql.Date; +import java.sql.NClob; +import java.sql.Time; +import java.sql.Timestamp; +import java.time.Duration; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.util.Calendar; + +import com.mysql.cj.protocol.ColumnDefinition; + +public interface QueryBindings { + + QueryBindings clone(); + + void setColumnDefinition(ColumnDefinition colDef); + + boolean isLoadDataQuery(); + + void setLoadDataQuery(boolean isLoadDataQuery); + + T[] getBindValues(); + + void setBindValues(T[] bindValues); + + /** + * + * @return true if bind values had long data + */ + boolean clearBindValues(); + + void checkParameterSet(int columnIndex); + + void checkAllParametersSet(); + + int getNumberOfExecutions(); + + void setNumberOfExecutions(int numberOfExecutions); + + void setValue(int paramIndex, byte[] val, MysqlType type); + + void setValue(int paramIndex, String val, MysqlType type); + + // Array getArray(int parameterIndex); + + void setAsciiStream(int parameterIndex, InputStream x); + + void setAsciiStream(int parameterIndex, InputStream x, int length); + + void setAsciiStream(int parameterIndex, InputStream x, long length); + + // InputStream getAsciiStream(int parameterIndex); + + void setBigDecimal(int parameterIndex, BigDecimal x); + + // BigDecimal getBigDecimal(int parameterIndex); + + void setBigInteger(int parameterIndex, BigInteger x); + + // BigInteger getBigInteger(int parameterIndex); + + void setBinaryStream(int parameterIndex, InputStream x); + + void setBinaryStream(int parameterIndex, InputStream x, int length); + + void setBinaryStream(int parameterIndex, InputStream x, long length); + + // InputStream getBinaryStream(int parameterIndex); + + void setBlob(int parameterIndex, java.sql.Blob x); + + void setBlob(int parameterIndex, InputStream inputStream); + + void setBlob(int parameterIndex, InputStream inputStream, long length); + + // java.sql.Blob getBlob(int parameterIndex); + + void setBoolean(int parameterIndex, boolean x); + + // boolean getBoolean(int parameterIndex); + + void setByte(int parameterIndex, byte x); + + // byte getByte(int parameterIndex); + + void setBytes(int parameterIndex, byte[] x); + + void setBytes(int parameterIndex, byte[] x, boolean checkForIntroducer, boolean escapeForMBChars); + + void setBytesNoEscape(int parameterIndex, byte[] parameterAsBytes); + + void setBytesNoEscapeNoQuotes(int parameterIndex, byte[] parameterAsBytes); + + // byte[] getBytes(int parameterIndex); + + void setCharacterStream(int parameterIndex, Reader reader); + + void setCharacterStream(int parameterIndex, Reader reader, int length); + + void setCharacterStream(int parameterIndex, Reader reader, long length); + + // Reader getCharacterStream(int parameterIndex); + + void setClob(int i, Clob x); + + void setClob(int parameterIndex, Reader reader); + + void setClob(int parameterIndex, Reader reader, long length); + + // Clob getClob(int parameterIndex); + + void setDate(int parameterIndex, Date x); + + void setDate(int parameterIndex, Date x, Calendar cal); + + // Date getDate(int parameterIndex); + + void setDouble(int parameterIndex, double x); + + // double getDouble(int parameterIndex) + + void setFloat(int parameterIndex, float x); + + // float getFloat(int parameterIndex); + + void setInt(int parameterIndex, int x); + + // int getInt(int parameterIndex); + + void setLong(int parameterIndex, long x); + + // long getLong(int parameterIndex); + + void setNCharacterStream(int parameterIndex, Reader value); + + void setNCharacterStream(int parameterIndex, Reader reader, long length); + + // Reader getNCharacterStream(int parameterIndex); + + void setNClob(int parameterIndex, Reader reader); + + void setNClob(int parameterIndex, Reader reader, long length); + + void setNClob(int parameterIndex, NClob value); + + // Reader getNClob(int parameterIndex); + + void setNString(int parameterIndex, String x); + + void setNull(int parameterIndex); + + boolean isNull(int parameterIndex); + + void setObject(int parameterIndex, Object parameterObj); + + void setObject(int parameterIndex, Object parameterObj, MysqlType targetMysqlType); + + void setObject(int parameterIndex, Object parameterObj, MysqlType targetMysqlType, int scaleOrLength); + + // Object getObject(int parameterIndex); + + // Ref getRef(int parameterIndex); + + void setShort(int parameterIndex, short x); + + // short getShort(int parameterIndex); + + void setString(int parameterIndex, String x); + + // String getString(int parameterIndex); + + void setTime(int parameterIndex, Time x); + + void setTime(int parameterIndex, Time x, Calendar cal); + + // Time getTime(int parameterIndex); + + void setTimestamp(int parameterIndex, Timestamp x, Calendar cal, MysqlType targetMysqlType); + + void setTimestamp(int parameterIndex, Timestamp x, MysqlType targetMysqlType); + + void setTimestamp(int parameterIndex, Timestamp x, Calendar targetCalendar, int fractionalLength, MysqlType targetMysqlType); + + void bindTimestamp(int parameterIndex, Timestamp x, Calendar targetCalendar, int fractionalLength, MysqlType targetMysqlType); + + // Timestamp getTimestamp(int parameterIndex); + + // URL getURL(int parameterIndex); + + byte[] getBytesRepresentation(int parameterIndex); + + byte[] getOrigBytes(int parameterIndex); + + void setLocalDate(int parameterIndex, LocalDate x, MysqlType targetMysqlType); + + void setLocalTime(int parameterIndex, LocalTime x, MysqlType targetMysqlType); + + void setLocalDateTime(int parameterIndex, LocalDateTime x, MysqlType targetMysqlType); + + void setDuration(int parameterIndex, Duration x, MysqlType targetMysqlType); + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/QueryResult.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/QueryResult.java new file mode 100644 index 0000000..56d51ee --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/QueryResult.java @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2018, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +public interface QueryResult { + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/ServerVersion.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/ServerVersion.java new file mode 100644 index 0000000..9a6c90c --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/ServerVersion.java @@ -0,0 +1,166 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +/** + * A server version. + */ +public class ServerVersion implements Comparable { + private String completeVersion; + private Integer major; + private Integer minor; + private Integer subminor; + + public ServerVersion(String completeVersion, int major, int minor, int subminor) { + this.completeVersion = completeVersion; + this.major = major; + this.minor = minor; + this.subminor = subminor; + } + + public ServerVersion(int major, int minor, int subminor) { + this(null, major, minor, subminor); + } + + public int getMajor() { + return this.major; + } + + public int getMinor() { + return this.minor; + } + + public int getSubminor() { + return this.subminor; + } + + /** + * A string representation of this version. If this version was parsed from, or provided with, a "complete" string which may contain more than just the + * version number, this string is returned verbatim. Otherwise, a string representation of the version numbers is given. + * + * @return string version representation + */ + @Override + public String toString() { + if (this.completeVersion != null) { + return this.completeVersion; + } + return String.format("%d.%d.%d", this.major, this.minor, this.subminor); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null || !ServerVersion.class.isAssignableFrom(obj.getClass())) { + return false; + } + ServerVersion another = (ServerVersion) obj; + if (this.getMajor() != another.getMajor() || this.getMinor() != another.getMinor() || this.getSubminor() != another.getSubminor()) { + return false; + } + return true; + } + + @Override + public int hashCode() { + int hash = 23; + hash += 19 * hash + this.major; + hash += 19 * hash + this.minor; + hash += 19 * hash + this.subminor; + return hash; + } + + public int compareTo(ServerVersion other) { + int c; + if ((c = this.major.compareTo(other.getMajor())) != 0) { + return c; + } else if ((c = this.minor.compareTo(other.getMinor())) != 0) { + return c; + } + return this.subminor.compareTo(other.getSubminor()); + } + + /** + * Does this version meet the minimum specified by `min'? + * + * @param min + * The minimum version to compare against. + * @return true if version meets the minimum specified by `min' + */ + public boolean meetsMinimum(ServerVersion min) { + return compareTo(min) >= 0; + } + + /** + * Parse the server version into major/minor/subminor. + * + * @param versionString + * string version representation + * @return {@link ServerVersion} + */ + public static ServerVersion parseVersion(final String versionString) { + int point = versionString.indexOf('.'); + + if (point != -1) { + try { + int serverMajorVersion = Integer.parseInt(versionString.substring(0, point)); + + String remaining = versionString.substring(point + 1, versionString.length()); + point = remaining.indexOf('.'); + + if (point != -1) { + int serverMinorVersion = Integer.parseInt(remaining.substring(0, point)); + + remaining = remaining.substring(point + 1, remaining.length()); + + int pos = 0; + + while (pos < remaining.length()) { + if ((remaining.charAt(pos) < '0') || (remaining.charAt(pos) > '9')) { + break; + } + + pos++; + } + + int serverSubminorVersion = Integer.parseInt(remaining.substring(0, pos)); + + return new ServerVersion(versionString, serverMajorVersion, serverMinorVersion, serverSubminorVersion); + } + } catch (NumberFormatException NFE1) { + } + } + + // can't parse the server version + return new ServerVersion(0, 0, 0); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/Session.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/Session.java new file mode 100644 index 0000000..09c522c --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/Session.java @@ -0,0 +1,222 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.net.SocketAddress; +import java.util.concurrent.CompletableFuture; +import java.util.function.Function; +import java.util.function.Predicate; +import java.util.stream.Collector; + +import com.mysql.cj.conf.HostInfo; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.CJOperationNotSupportedException; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.ExceptionInterceptor; +import com.mysql.cj.log.Log; +import com.mysql.cj.log.ProfilerEventHandler; +import com.mysql.cj.protocol.Message; +import com.mysql.cj.protocol.Protocol; +import com.mysql.cj.protocol.ResultBuilder; +import com.mysql.cj.protocol.ServerSession; +import com.mysql.cj.result.Row; + +/** + * {@link Session} exposes logical level which user API uses internally to call {@link Protocol} methods. + * It's a higher-level abstraction than MySQL server session ({@link ServerSession}). {@link Protocol} and {@link ServerSession} methods + * should never be used directly from user API. + * + */ +public interface Session { + + PropertySet getPropertySet(); + + MessageBuilder getMessageBuilder(); + + /** + * Re-authenticates as the given user and password + * + * @param userName + * DB user name + * @param password + * DB user password + * @param database + * database name + * + */ + void changeUser(String userName, String password, String database); + + ExceptionInterceptor getExceptionInterceptor(); + + void setExceptionInterceptor(ExceptionInterceptor exceptionInterceptor); + + /** + * Log-off of the MySQL server and close the socket. + * + */ + void quit(); + + /** + * Clobbers the physical network connection and marks this session as closed. + */ + void forceClose(); + + /** + * Does the version of the MySQL server we are connected to meet the given + * minimums? + * + * @param major + * major version number + * @param minor + * minor version number + * @param subminor + * sub-minor version number + * @return true if current server version equal or higher than provided one + */ + boolean versionMeetsMinimum(int major, int minor, int subminor); + + long getThreadId(); + + boolean isSetNeededForAutoCommitMode(boolean autoCommitFlag); + + /** + * Returns the log mechanism that should be used to log information from/for this Session. + * + * @return the Log instance to use for logging messages. + */ + Log getLog(); + + /** + * Returns the current ProfilerEventHandler or initializes a new one if none exists. + * + * @return the {@link ProfilerEventHandler} object. + */ + ProfilerEventHandler getProfilerEventHandler(); + + HostInfo getHostInfo(); + + String getQueryTimingUnits(); + + ServerSession getServerSession(); + + boolean isSSLEstablished(); + + SocketAddress getRemoteSocketAddress(); + + String getProcessHost(); + + /** + * Add listener for this session status changes. + * + * @param l + * {@link SessionEventListener} instance. + */ + void addListener(SessionEventListener l); + + /** + * Remove session listener. + * + * @param l + * {@link SessionEventListener} instance. + */ + void removeListener(SessionEventListener l); + + public static interface SessionEventListener { + void handleNormalClose(); + + void handleReconnect(); + + void handleCleanup(Throwable whyCleanedUp); + } + + boolean isClosed(); + + String getIdentifierQuoteString(); + + DataStoreMetadata getDataStoreMetadata(); + + /** + * Synchronously query database with applying rows filtering and mapping. + * + * @param message + * query message + * @param rowFilter + * row filter function + * @param rowMapper + * row map function + * @param collector + * result collector + * @param + * Message type + * @param + * Row type + * @param + * Result type + * @return List of rows + */ + default RES query(M message, Predicate rowFilter, Function rowMapper, Collector collector) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not supported"); + } + + /** + * Synchronously query database. + * + * @param message + * query message + * @param resultBuilder + * ResultBuilder instance + * @param + * Message type + * @param + * Result type + * @return {@link QueryResult} object + */ + default R query(M message, ResultBuilder resultBuilder) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not supported"); + } + + /** + * Asynchronously query database. + * + * @param message + * query message + * @param resultBuilder + * ResultBuilder instance + * @param + * Message type + * @param + * Result type + * @return CompletableFuture providing a {@link QueryResult} object + */ + default CompletableFuture queryAsync(M message, ResultBuilder resultBuilder) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not supported"); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/TransactionEventHandler.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/TransactionEventHandler.java new file mode 100644 index 0000000..3316fa3 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/TransactionEventHandler.java @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2017, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +public interface TransactionEventHandler { + + void transactionBegun(); + + void transactionCompleted(); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/WarningListener.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/WarningListener.java new file mode 100644 index 0000000..b9d6c30 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/WarningListener.java @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +/** + * A warning listener is notified of warnings as they happen throughout the driver. They can be queued for consumption by JDBC clients, thrown as exceptions, or + * ignored. + */ +public interface WarningListener { + void warningEncountered(String warning); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/callback/MysqlCallback.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/callback/MysqlCallback.java new file mode 100644 index 0000000..9683d44 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/callback/MysqlCallback.java @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.callback; + +/** + * Implementations of this interface can be passed to a {@link MysqlCallbackHandler} so that the owner of the callback handler and its caller can share data in + * a way that would otherwise require tight coupling. + */ +public interface MysqlCallback { +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/callback/MysqlCallbackHandler.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/callback/MysqlCallbackHandler.java new file mode 100644 index 0000000..b3e498b --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/callback/MysqlCallbackHandler.java @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.callback; + +/** + * A functional interface for implementing callback handlers. + * + * The single method {@link MysqlCallbackHandler#handle(MysqlCallback)} is called by the classes where the callback handler is passed when they need to share + * data with the caller. The kind of data to exchange depends on the implementations of {@link MysqlCallback} they choose to use. + */ +@FunctionalInterface +public interface MysqlCallbackHandler { + /** + * Exchanges information between the caller of this method and the owner of the {@link MysqlCallbackHandler} instance. The method can be called multiple + * times with different callback implementations to exchange different types of information. A typical {@link MysqlCallbackHandler} implementation looks + * like: + * + * 
+     * private MysqlCallbackHandler callbackHandler = (cb) -> {
+     *     if (cb instanceof UsernameCallback) {
+     *         this.username = ((UsernameCallback) cb).getUsername();
+     *     }
+     * };
+     *
+ * + * @param cb + * + */ + void handle(MysqlCallback cb); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/callback/UsernameCallback.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/callback/UsernameCallback.java new file mode 100644 index 0000000..1f6cbf1 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/callback/UsernameCallback.java @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.callback; + +/** + * A callback that can be used to exchange username information to a callback handler owner. + */ +public class UsernameCallback implements MysqlCallback { + private String username; + + public UsernameCallback(String username) { + this.username = username; + } + + /** + * Get the username provided by the caller of {@link MysqlCallbackHandler#handle(MysqlCallback)}. + * + * @return + * the username to pass over to the callback handler. + */ + public String getUsername() { + return this.username; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/ConnectionPropertiesTransform.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/ConnectionPropertiesTransform.java new file mode 100644 index 0000000..9eb4f97 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/ConnectionPropertiesTransform.java @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +import java.util.Properties; + +/** + * Implement this interface, and pass the class name as the 'propertiesTransform' property in your URL, and the driver will pass the properties it has + * parsed to your transform implementation so that you can modify/substitute/add any that you desire. + */ +public interface ConnectionPropertiesTransform { + /** + * The driver will call this method if the user has loaded your + * implementation of this interface by specifying the 'propertiesTransform' + * property in their URL. + * + * @param props + * the properties as passed by the driver (never null) + * + * @return the same properties with any transformations that your + * implementation has made + * + */ + Properties transformProperties(Properties props); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/ConnectionUrl.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/ConnectionUrl.java new file mode 100644 index 0000000..cc292cd --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/ConnectionUrl.java @@ -0,0 +1,830 @@ +/* + * Copyright (c) 2016, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +import static com.mysql.cj.util.StringUtils.isNullOrEmpty; + +import java.io.IOException; +import java.io.InputStream; +import java.sql.DriverManager; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Properties; +import java.util.TreeMap; +import java.util.concurrent.locks.ReadWriteLock; +import java.util.concurrent.locks.ReentrantReadWriteLock; +import java.util.stream.Collectors; + +import javax.naming.NamingException; + +import com.mysql.cj.Messages; +import com.mysql.cj.exceptions.CJException; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.InvalidConnectionAttributeException; +import com.mysql.cj.exceptions.UnsupportedConnectionStringException; +import com.mysql.cj.exceptions.WrongArgumentException; +import com.mysql.cj.util.DnsSrv; +import com.mysql.cj.util.DnsSrv.SrvRecord; +import com.mysql.cj.util.LRUCache; +import com.mysql.cj.util.Util; + +/** + * A container for a database URL and a collection of given connection arguments. + * The connection string is parsed and split by its components, each of which is then processed and fixed according to the needs of the connection type. + * This abstract class holds all common behavior to all connection string types. Its subclasses must implement their own specifics such as classifying hosts by + * type or apply validation rules. + */ +public abstract class ConnectionUrl implements DatabaseUrlContainer { + public static final String DEFAULT_HOST = "localhost"; + public static final int DEFAULT_PORT = 3306; + + private static final LRUCache connectionUrlCache = new LRUCache<>(100); + private static final ReadWriteLock rwLock = new ReentrantReadWriteLock(); + + /** + * The rules describing the number of hosts a database URL may contain. + */ + public enum HostsCardinality { + SINGLE { + @Override + public boolean assertSize(int n) { + return n == 1; + } + }, + MULTIPLE { + @Override + public boolean assertSize(int n) { + return n > 1; + } + }, + ONE_OR_MORE { + @Override + public boolean assertSize(int n) { + return n >= 1; + } + }; + + public abstract boolean assertSize(int n); + } + + /** + * The database URL type which is determined by the scheme section of the connection string. + */ + public enum Type { + // DNS SRV schemes (cardinality is validated by implementing classes): + FAILOVER_DNS_SRV_CONNECTION("jdbc:mysql+srv:", HostsCardinality.ONE_OR_MORE, "com.mysql.cj.conf.url.FailoverDnsSrvConnectionUrl"), // + LOADBALANCE_DNS_SRV_CONNECTION("jdbc:mysql+srv:loadbalance:", HostsCardinality.ONE_OR_MORE, "com.mysql.cj.conf.url.LoadBalanceDnsSrvConnectionUrl"), // + REPLICATION_DNS_SRV_CONNECTION("jdbc:mysql+srv:replication:", HostsCardinality.ONE_OR_MORE, "com.mysql.cj.conf.url.ReplicationDnsSrvConnectionUrl"), // + XDEVAPI_DNS_SRV_SESSION("mysqlx+srv:", HostsCardinality.ONE_OR_MORE, "com.mysql.cj.conf.url.XDevApiDnsSrvConnectionUrl"), // + // Standard schemes: + SINGLE_CONNECTION("jdbc:mysql:", HostsCardinality.SINGLE, "com.mysql.cj.conf.url.SingleConnectionUrl", PropertyKey.dnsSrv, FAILOVER_DNS_SRV_CONNECTION), // + FAILOVER_CONNECTION("jdbc:mysql:", HostsCardinality.MULTIPLE, "com.mysql.cj.conf.url.FailoverConnectionUrl", PropertyKey.dnsSrv, + FAILOVER_DNS_SRV_CONNECTION), // + LOADBALANCE_CONNECTION("jdbc:mysql:loadbalance:", HostsCardinality.ONE_OR_MORE, "com.mysql.cj.conf.url.LoadBalanceConnectionUrl", PropertyKey.dnsSrv, + LOADBALANCE_DNS_SRV_CONNECTION), // + REPLICATION_CONNECTION("jdbc:mysql:replication:", HostsCardinality.ONE_OR_MORE, "com.mysql.cj.conf.url.ReplicationConnectionUrl", PropertyKey.dnsSrv, + REPLICATION_DNS_SRV_CONNECTION), // + XDEVAPI_SESSION("mysqlx:", HostsCardinality.ONE_OR_MORE, "com.mysql.cj.conf.url.XDevApiConnectionUrl", PropertyKey.xdevapiDnsSrv, + XDEVAPI_DNS_SRV_SESSION); + + private String scheme; + private HostsCardinality cardinality; + private String implementingClass; + private PropertyKey dnsSrvPropertyKey; + private Type alternateDnsSrvType; + + private Type(String scheme, HostsCardinality cardinality, String implementingClass) { + this(scheme, cardinality, implementingClass, null, null); + } + + private Type(String scheme, HostsCardinality cardinality, String implementingClass, PropertyKey dnsSrvPropertyKey, Type alternateDnsSrvType) { + this.scheme = scheme; + this.cardinality = cardinality; + this.implementingClass = implementingClass; + this.dnsSrvPropertyKey = dnsSrvPropertyKey; + this.alternateDnsSrvType = alternateDnsSrvType; + } + + public String getScheme() { + return this.scheme; + } + + public HostsCardinality getCardinality() { + return this.cardinality; + } + + public String getImplementingClass() { + return this.implementingClass; + } + + public PropertyKey getDnsSrvPropertyKey() { + return this.dnsSrvPropertyKey; + } + + public Type getAlternateDnsSrvType() { + return this.alternateDnsSrvType; + } + + /** + * Returns the {@link Type} corresponding to the given scheme and number of hosts, if any. + * Otherwise throws an {@link UnsupportedConnectionStringException}. + * Calling this method with the argument n lower than 0 skips the hosts cardinality validation. + * + * @param scheme + * one of supported schemes + * @param n + * the number of hosts in the database URL + * @return the {@link Type} corresponding to the given protocol and number of hosts + */ + public static Type fromValue(String scheme, int n) { + for (Type t : values()) { + if (t.getScheme().equalsIgnoreCase(scheme) && (n < 0 || t.getCardinality().assertSize(n))) { + return t; + } + } + if (n < 0) { + throw ExceptionFactory.createException(UnsupportedConnectionStringException.class, + Messages.getString("ConnectionString.5", new Object[] { scheme })); + } + throw ExceptionFactory.createException(UnsupportedConnectionStringException.class, + Messages.getString("ConnectionString.6", new Object[] { scheme, n })); + } + + /** + * Instantiates a class that implements the right type of connection URLs for the given {@link ConnectionUrlParser}. + * + * @param parser + * the {@link ConnectionUrlParser} containing the URL components. + * @param info + * a connection properties map to add to the {@link ConnectionUrl} structure. + * @return + * an instance of {@link ConnectionUrl}. + */ + public static ConnectionUrl getConnectionUrlInstance(ConnectionUrlParser parser, Properties info) { + int hostsCount = parser.getHosts().size(); + Type type = fromValue(parser.getScheme(), hostsCount); + PropertyKey dnsSrvPropKey = type.getDnsSrvPropertyKey(); + Map parsedProperties; + + // Check if the Type must be replaced by a DNS SRV one. + if (dnsSrvPropKey != null && type.getAlternateDnsSrvType() != null) { + if (info != null && info.containsKey(dnsSrvPropKey.getKeyName())) { // Properties map prevails over connection string options. + if ((Boolean) PropertyDefinitions.getPropertyDefinition(dnsSrvPropKey).parseObject(info.getProperty(dnsSrvPropKey.getKeyName()), null)) { + type = fromValue(type.getAlternateDnsSrvType().getScheme(), hostsCount); + } + } else if ((parsedProperties = parser.getProperties()).containsKey(dnsSrvPropKey.getKeyName()) && (Boolean) PropertyDefinitions + .getPropertyDefinition(dnsSrvPropKey).parseObject(parsedProperties.get(dnsSrvPropKey.getKeyName()), null)) { + type = fromValue(type.getAlternateDnsSrvType().getScheme(), hostsCount); + } + } + + return type.getImplementingInstance(parser, info); + } + + /** + * Checks if the given scheme corresponds to one of the connection types the driver supports. + * + * @param scheme + * scheme part from connection string, like "jdbc:mysql:" + * @return true if the given scheme is supported by driver + */ + public static boolean isSupported(String scheme) { + for (Type t : values()) { + if (t.getScheme().equalsIgnoreCase(scheme)) { + return true; + } + } + return false; + } + + /** + * Instantiates a class that implements this type of connection URLs with the given arguments. + * + * @param parser + * the {@link ConnectionUrlParser} containing the URL components. + * @param info + * a connection properties map to add to the {@link ConnectionUrl} structure. + * @return + * an instance of {@link ConnectionUrl}. + */ + private ConnectionUrl getImplementingInstance(ConnectionUrlParser parser, Properties info) { + return (ConnectionUrl) Util.getInstance(getImplementingClass(), new Class[] { ConnectionUrlParser.class, Properties.class }, + new Object[] { parser, info }, null); + } + } + + protected Type type; + protected String originalConnStr; + protected String originalDatabase; + protected List hosts = new ArrayList<>(); + protected Map properties = new HashMap<>(); + ConnectionPropertiesTransform propertiesTransformer; + + /** + * Static factory method that returns either a new instance of a {@link ConnectionUrl} or a cached one. + * Returns "null" it can't handle the connection string. + * + * @param connString + * the connection string + * @param info + * the connection arguments map + * @return an instance of a {@link ConnectionUrl} or "null" if isn't able to handle the connection string + */ + public static ConnectionUrl getConnectionUrlInstance(String connString, Properties info) { + if (connString == null) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("ConnectionString.0")); + } + String connStringCacheKey = buildConnectionStringCacheKey(connString, info); + ConnectionUrl connectionUrl; + + rwLock.readLock().lock(); + connectionUrl = connectionUrlCache.get(connStringCacheKey); + if (connectionUrl == null) { + rwLock.readLock().unlock(); + rwLock.writeLock().lock(); + try { + // Check again, in the meantime it could have been cached by another thread. + connectionUrl = connectionUrlCache.get(connStringCacheKey); + if (connectionUrl == null) { + ConnectionUrlParser connStrParser = ConnectionUrlParser.parseConnectionString(connString); + connectionUrl = Type.getConnectionUrlInstance(connStrParser, info); + connectionUrlCache.put(connStringCacheKey, connectionUrl); + } + rwLock.readLock().lock(); + } finally { + rwLock.writeLock().unlock(); + } + } + rwLock.readLock().unlock(); + return connectionUrl; + } + + /** + * Builds a connection URL cache map key based on the connection string itself plus the string representation of the given connection properties. + * + * @param connString + * the connection string + * @param info + * the connection arguments map + * @return a connection string cache map key + */ + private static String buildConnectionStringCacheKey(String connString, Properties info) { + StringBuilder sbKey = new StringBuilder(connString); + sbKey.append("\u00A7"); // Section sign. + sbKey.append( + info == null ? null : info.stringPropertyNames().stream().map(k -> k + "=" + info.getProperty(k)).collect(Collectors.joining(", ", "{", "}"))); + return sbKey.toString(); + } + + /** + * Checks if this {@link ConnectionUrl} is able to process the given database URL. + * + * @param connString + * the connection string + * @return true if this class is able to process the given URL, false otherwise + */ + public static boolean acceptsUrl(String connString) { + return ConnectionUrlParser.isConnectionStringSupported(connString); + } + + /** + * Empty constructor. Required for subclasses initialization. + */ + protected ConnectionUrl() { + } + + /** + * Constructor for unsupported URLs + * + * @param origUrl + * URLs + */ + public ConnectionUrl(String origUrl) { + this.originalConnStr = origUrl; + } + + /** + * Constructs an instance of {@link ConnectionUrl}, performing all the required initializations. + * + * @param connStrParser + * a {@link ConnectionUrlParser} instance containing the parsed version of the original connection string + * @param info + * the connection arguments map + */ + protected ConnectionUrl(ConnectionUrlParser connStrParser, Properties info) { + this.originalConnStr = connStrParser.getDatabaseUrl(); + this.originalDatabase = connStrParser.getPath() == null ? "" : connStrParser.getPath(); + collectProperties(connStrParser, info); // Fill properties before filling hosts info. + collectHostsInfo(connStrParser); + } + + /** + * Joins the connection arguments from the connection string with the ones from the given connection arguments map collecting them in a single map. + * Additionally may also collect other connection arguments from configuration files. + * + * @param connStrParser + * the {@link ConnectionUrlParser} from where to collect the properties + * @param info + * the connection arguments map + */ + protected void collectProperties(ConnectionUrlParser connStrParser, Properties info) { + // Fill in the properties from the connection string. + connStrParser.getProperties().entrySet().stream().forEach(e -> this.properties.put(PropertyKey.normalizeCase(e.getKey()), e.getValue())); + + // Properties passed in override the ones from the connection string. + if (info != null) { + info.stringPropertyNames().stream().forEach(k -> this.properties.put(PropertyKey.normalizeCase(k), info.getProperty(k))); + } + + // Collect properties from additional sources. + setupPropertiesTransformer(); + expandPropertiesFromConfigFiles(this.properties); + injectPerTypeProperties(this.properties); + } + + /** + * Sets up the {@link ConnectionPropertiesTransform} if one was provided. + */ + protected void setupPropertiesTransformer() { + String propertiesTransformClassName = this.properties.get(PropertyKey.propertiesTransform.getKeyName()); + if (!isNullOrEmpty(propertiesTransformClassName)) { + try { + this.propertiesTransformer = (ConnectionPropertiesTransform) Class.forName(propertiesTransformClassName).newInstance(); + } catch (InstantiationException | IllegalAccessException | ClassNotFoundException | CJException e) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, + Messages.getString("ConnectionString.9", new Object[] { propertiesTransformClassName, e.toString() }), e); + } + } + } + + /** + * Expands the connection argument "useConfig" by reading the mentioned configuration files. + * + * @param props + * a connection arguments map from where to read the "useConfig" property and where to save the loaded properties. + */ + protected void expandPropertiesFromConfigFiles(Map props) { + // Properties from config files should not override the existing ones. + String configFiles = props.get(PropertyKey.useConfigs.getKeyName()); + if (!isNullOrEmpty(configFiles)) { + Properties configProps = getPropertiesFromConfigFiles(configFiles); + configProps.stringPropertyNames().stream().map(PropertyKey::normalizeCase).filter(k -> !props.containsKey(k)) + .forEach(k -> props.put(k, configProps.getProperty(k))); + } + } + + /** + * Returns a map containing the properties read from the given configuration files. Multiple files can be referenced using a comma as separator. + * + * @param configFiles + * the list of the configuration files to read + * @return the map containing all the properties read + */ + public static Properties getPropertiesFromConfigFiles(String configFiles) { + Properties configProps = new Properties(); + for (String configFile : configFiles.split(",")) { + try (InputStream configAsStream = ConnectionUrl.class.getResourceAsStream("/com/mysql/cj/configurations/" + configFile + ".properties")) { + if (configAsStream == null) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, + Messages.getString("ConnectionString.10", new Object[] { configFile })); + } + configProps.load(configAsStream); + } catch (IOException e) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, + Messages.getString("ConnectionString.11", new Object[] { configFile }), e); + } + } + return configProps; + } + + /** + * Subclasses must override this method if they need to inject additional properties in the connection arguments map while it's being constructed. + * + * @param props + * the properties already containing all known connection arguments + */ + protected void injectPerTypeProperties(Map props) { + return; + } + + /** + * Some acceptable property values have changed in c/J 8.0 but old values remain hard-coded in widely used software. + * So, old values must be accepted and translated to new ones. + * + * @param props + * the host properties map to fix + */ + protected void replaceLegacyPropertyValues(Map props) { + // Workaround for zeroDateTimeBehavior=convertToNull hard-coded in NetBeans + String zeroDateTimeBehavior = props.get(PropertyKey.zeroDateTimeBehavior.getKeyName()); + if (zeroDateTimeBehavior != null && zeroDateTimeBehavior.equalsIgnoreCase("convertToNull")) { + props.put(PropertyKey.zeroDateTimeBehavior.getKeyName(), "CONVERT_TO_NULL"); + } + } + + /** + * Collects the hosts information from the {@link ConnectionUrlParser}. + * + * @param connStrParser + * the {@link ConnectionUrlParser} from where to collect the hosts information + */ + protected void collectHostsInfo(ConnectionUrlParser connStrParser) { + connStrParser.getHosts().stream().map(this::fixHostInfo).forEach(this.hosts::add); + } + + /** + * Fixes the host information by moving data around and filling in missing data. + * Applies properties transformations to the collected properties if {@link ConnectionPropertiesTransform} was declared in the connection arguments. + * + * @param hi + * the host information data to fix + * @return a new {@link HostInfo} with all required data + */ + protected HostInfo fixHostInfo(HostInfo hi) { + Map hostProps = new HashMap<>(); + + // Add global connection arguments. + hostProps.putAll(this.properties); + // Add/override host specific connection arguments. + hi.getHostProperties().entrySet().stream().forEach(e -> hostProps.put(PropertyKey.normalizeCase(e.getKey()), e.getValue())); + // Add the database name + if (!hostProps.containsKey(PropertyKey.DBNAME.getKeyName())) { + hostProps.put(PropertyKey.DBNAME.getKeyName(), getDatabase()); + } + + preprocessPerTypeHostProperties(hostProps); + + String host = hostProps.remove(PropertyKey.HOST.getKeyName()); + if (!isNullOrEmpty(hi.getHost())) { + host = hi.getHost(); + } else if (isNullOrEmpty(host)) { + host = getDefaultHost(); + } + + String portAsString = hostProps.remove(PropertyKey.PORT.getKeyName()); + int port = hi.getPort(); + if (port == HostInfo.NO_PORT && !isNullOrEmpty(portAsString)) { + try { + port = Integer.valueOf(portAsString); + } catch (NumberFormatException e) { + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("ConnectionString.7", new Object[] { hostProps.get(PropertyKey.PORT.getKeyName()) }), e); + } + } + if (port == HostInfo.NO_PORT) { + port = getDefaultPort(); + } + + String user = hostProps.remove(PropertyKey.USER.getKeyName()); + if (!isNullOrEmpty(hi.getUser())) { + user = hi.getUser(); + } else if (isNullOrEmpty(user)) { + user = getDefaultUser(); + } + + String password = hostProps.remove(PropertyKey.PASSWORD.getKeyName()); + if (!isNullOrEmpty(hi.getPassword())) { + password = hi.getPassword(); + } else if (isNullOrEmpty(password)) { + password = getDefaultPassword(); + } + + expandPropertiesFromConfigFiles(hostProps); + fixProtocolDependencies(hostProps); + replaceLegacyPropertyValues(hostProps); + + return buildHostInfo(host, port, user, password, hostProps); + } + + /** + * Subclasses should override this to perform any required pre-processing on the host information properties. + * + * @param hostProps + * the host properties map to process + */ + protected void preprocessPerTypeHostProperties(Map hostProps) { + // To be overridden in subclasses if needed. + } + + /** + * Returns the default host. Subclasses must override this method if they have different default host value. + * + * @return the default host + */ + public String getDefaultHost() { + return DEFAULT_HOST; + } + + /** + * Returns the default port. Subclasses must override this method if they have different default port value. + * + * @return the default port + */ + public int getDefaultPort() { + return DEFAULT_PORT; + } + + /** + * Returns the default user. Usually the one provided in the method {@link DriverManager#getConnection(String, String, String)} or as connection argument. + * + * @return the default user + */ + public String getDefaultUser() { + return this.properties.get(PropertyKey.USER.getKeyName()); + } + + /** + * Returns the default password. Usually the one provided in the method {@link DriverManager#getConnection(String, String, String)} or as connection + * argument. + * + * @return the default password + */ + public String getDefaultPassword() { + return this.properties.get(PropertyKey.PASSWORD.getKeyName()); + } + + /** + * Fixes the protocol (TCP vs PIPE) dependencies for the given host properties map. + * + * @param hostProps + * the host properties map to fix + */ + protected void fixProtocolDependencies(Map hostProps) { + String protocol = hostProps.get(PropertyKey.PROTOCOL.getKeyName()); + if (!isNullOrEmpty(protocol) && protocol.equalsIgnoreCase("PIPE")) { + if (!hostProps.containsKey(PropertyKey.socketFactory.getKeyName())) { + hostProps.put(PropertyKey.socketFactory.getKeyName(), "com.mysql.cj.protocol.NamedPipeSocketFactory"); + } + } + } + + /** + * Returns this connection URL type. + * + * @return the connection URL type + */ + public Type getType() { + return this.type; + } + + /** + * Returns the original database URL that produced this connection string. + * + * @return the original database URL + */ + @Override + public String getDatabaseUrl() { + return this.originalConnStr; + } + + /** + * Returns the database from this connection URL. Note that a "DBNAME" property overrides the database identified in the connection string. + * + * @return the database name + */ + public String getDatabase() { + return this.properties.containsKey(PropertyKey.DBNAME.getKeyName()) ? this.properties.get(PropertyKey.DBNAME.getKeyName()) : this.originalDatabase; + } + + /** + * Returns the number of hosts in this connection URL. + * + * @return the number of hosts + */ + public int hostsCount() { + return this.hosts.size(); + } + + /** + * Returns the single or first host info structure. + * + * @return the first host info structure + */ + public HostInfo getMainHost() { + return this.hosts.isEmpty() ? null : this.hosts.get(0); + } + + /** + * Returns a list of the hosts in this connection URL. + * + * @return the hosts list from this connection URL + */ + public List getHostsList() { + return getHostsList(HostsListView.ALL); + } + + /** + * Returns a list of the hosts in this connection URL, filtered for the given view. + * + * By default returns all hosts. Subclasses should override this method in order to implement support for different views, usually by splitting the global + * hosts into smaller sub-lists. + * + * @param view + * the type of the view to use in the returned list of hosts. This argument is ignored in this implementation. + * @return + * the hosts list from this connection URL, filtered for the given view. + */ + public List getHostsList(HostsListView view) { + return Collections.unmodifiableList(this.hosts); + } + + /** + * Returns an existing host info with the same host:port part or spawns a new isolated host info based on this connection URL if none was found. + * + * @param hostPortPair + * the host:port part to search for + * @return the existing host info or a new independent one + */ + public HostInfo getHostOrSpawnIsolated(String hostPortPair) { + return getHostOrSpawnIsolated(hostPortPair, this.hosts); + } + + /** + * Returns an existing host info with the same host:port part or spawns a new isolated host info based on this connection URL if none was found. + * + * @param hostPortPair + * the host:port part to search for + * @param hostsList + * the hosts list from where to search the host list + * @return the existing host info or a new independent one + */ + public HostInfo getHostOrSpawnIsolated(String hostPortPair, List hostsList) { + for (HostInfo hi : hostsList) { + if (hostPortPair.equals(hi.getHostPortPair())) { + return hi; + } + } + + ConnectionUrlParser.Pair hostAndPort = ConnectionUrlParser.parseHostPortPair(hostPortPair); + String host = hostAndPort.left; + Integer port = hostAndPort.right; + String user = getDefaultUser(); + String password = getDefaultPassword(); + + return buildHostInfo(host, port, user, password, this.properties); + } + + /** + * Creates a new {@link HostInfo} structure with the given components, passing through the properties transformer if there is one defined in this connection + * string; + * + * @param host + * the host + * @param port + * the port + * @param user + * the user name + * @param password + * the password + * @param hostProps + * the host properties map + * @return a new instance of {@link HostInfo} + */ + protected HostInfo buildHostInfo(String host, int port, String user, String password, Map hostProps) { + // Apply properties transformations if needed. + if (this.propertiesTransformer != null) { + Properties props = new Properties(); + props.putAll(hostProps); + + props.setProperty(PropertyKey.HOST.getKeyName(), host); + props.setProperty(PropertyKey.PORT.getKeyName(), String.valueOf(port)); + if (user != null) { + props.setProperty(PropertyKey.USER.getKeyName(), user); + } + if (password != null) { + props.setProperty(PropertyKey.PASSWORD.getKeyName(), password); + } + + Properties transformedProps = this.propertiesTransformer.transformProperties(props); + + host = transformedProps.getProperty(PropertyKey.HOST.getKeyName()); + try { + port = Integer.parseInt(transformedProps.getProperty(PropertyKey.PORT.getKeyName())); + } catch (NumberFormatException e) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("ConnectionString.8", + new Object[] { PropertyKey.PORT.getKeyName(), transformedProps.getProperty(PropertyKey.PORT.getKeyName()) }), e); + } + user = transformedProps.getProperty(PropertyKey.USER.getKeyName()); + password = transformedProps.getProperty(PropertyKey.PASSWORD.getKeyName()); + + Map transformedHostProps = new TreeMap<>(String.CASE_INSENSITIVE_ORDER); + transformedProps.stringPropertyNames().stream().forEach(k -> transformedHostProps.put(k, transformedProps.getProperty(k))); + // Remove surplus keys. + transformedHostProps.remove(PropertyKey.HOST.getKeyName()); + transformedHostProps.remove(PropertyKey.PORT.getKeyName()); + transformedHostProps.remove(PropertyKey.USER.getKeyName()); + transformedHostProps.remove(PropertyKey.PASSWORD.getKeyName()); + + hostProps = transformedHostProps; + } + + return new HostInfo(this, host, port, user, password, hostProps); + } + + /** + * Returns the original (common to all hosts) connection arguments as provided in the connection string query section. + * + * @return the original (common to all hosts) connection arguments + */ + public Map getOriginalProperties() { + return Collections.unmodifiableMap(this.properties); + } + + /** + * Returns a {@link Properties} instance containing the connection arguments extracted from the URL query section, i.e., per host attributes are excluded. + * Applies properties transformations to the collected properties if {@link ConnectionPropertiesTransform} was declared in the connection arguments. + * + * @return a {@link Properties} instance containing the common connection arguments. + */ + public Properties getConnectionArgumentsAsProperties() { + Properties props = new Properties(); + if (this.properties != null) { + props.putAll(this.properties); + } + + return this.propertiesTransformer != null ? this.propertiesTransformer.transformProperties(props) : props; + } + + /** + * Returns a hosts list built from the result of the DNS SRV lookup for the original host name. + * + * @param srvHost + * the {@link HostInfo} from where to get the DNS SRV service name to lookup. + * @return + * the hosts list from the result of the DNS SRV lookup, filtered for the given view. + */ + public List getHostsListFromDnsSrv(HostInfo srvHost) { + String srvServiceName = srvHost.getHost(); + List srvRecords = null; + + try { + srvRecords = DnsSrv.lookupSrvRecords(srvServiceName); + } catch (NamingException e) { + throw ExceptionFactory.createException(Messages.getString("ConnectionString.26", new Object[] { srvServiceName }), e); + } + if (srvRecords == null || srvRecords.size() == 0) { + throw ExceptionFactory.createException(Messages.getString("ConnectionString.26", new Object[] { srvServiceName })); + } + + return Collections.unmodifiableList(srvRecordsToHostsList(srvRecords, srvHost)); + } + + /** + * Converts a list of DNS SRV records into a hosts list. + * + * @param srvRecords + * the list of DNS SRV records. + * @param baseHostInfo + * the {@link HostInfo} to use as source of all common host specific options. + * @return + * a list of hosts. + */ + private List srvRecordsToHostsList(List srvRecords, HostInfo baseHostInfo) { + return srvRecords.stream() + .map(s -> buildHostInfo(s.getTarget(), s.getPort(), baseHostInfo.getUser(), baseHostInfo.getPassword(), baseHostInfo.getHostProperties())) + .collect(Collectors.toList()); + } + + /** + * Returns a string representation of this object. + * + * @return a string representation of this object + */ + @Override + public String toString() { + StringBuilder asStr = new StringBuilder(super.toString()); + asStr.append(String.format(" :: {type: \"%s\", hosts: %s, database: \"%s\", properties: %s, propertiesTransformer: %s}", this.type, this.hosts, + this.originalDatabase, this.properties, this.propertiesTransformer)); + return asStr.toString(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/ConnectionUrlParser.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/ConnectionUrlParser.java new file mode 100644 index 0000000..b1862e9 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/ConnectionUrlParser.java @@ -0,0 +1,707 @@ +/* + * Copyright (c) 2016, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +import static com.mysql.cj.util.StringUtils.isNullOrEmpty; +import static com.mysql.cj.util.StringUtils.safeTrim; + +import java.io.UnsupportedEncodingException; +import java.net.URI; +import java.net.URLDecoder; +import java.nio.charset.StandardCharsets; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import com.mysql.cj.Messages; +import com.mysql.cj.conf.ConnectionUrl.Type; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.UnsupportedConnectionStringException; +import com.mysql.cj.exceptions.WrongArgumentException; +import com.mysql.cj.util.StringUtils; + +/** + * This class parses a connection string using the general URI structure defined in RFC 3986. Instead of using a URI instance to ensure the correct syntax of + * the connection string, this implementation uses regular expressions which is faster but also less strict in terms of validations. This actually works better + * because database URLs don't exactly stick to the RFC 3986 rules. + *

+ * scheme://authority/path?query#fragment + *

+ * This results in splitting the connection string URL and processing its internal parts: + *

+ *
scheme
+ *
The protocol and subprotocol identification. Usually "jdbc:mysql:" or "mysqlx:".
+ *
authority
+ *
Contains information about the user credentials and/or the host and port information. Unlike its definition in the RFC 3986 specification, there can be + * multiple authority sections separated by a single comma (,) in a connection string. It is also possible to use an alternative syntax for the user and/or host + * identification, that also allows setting per host connection properties, in the form of + * "[user[:password]@]address=(key1=value)[(key2=value)]...[,address=(key3=value)[(key4=value)]...]...".
+ *
path
+ *
Corresponds to the database identification.
+ *
query
+ *
The connection properties, written as "propertyName1[=[propertyValue1]][&propertyName2[=[propertyValue2]]]..."
+ *
fragment
+ *
The fragment section is ignored in Connector/J connection strings.
+ *
+ */ +public class ConnectionUrlParser implements DatabaseUrlContainer { + private static final String DUMMY_SCHEMA = "cj://"; + private static final String USER_PASS_SEPARATOR = ":"; + private static final String USER_HOST_SEPARATOR = "@"; + private static final String HOSTS_SEPARATOR = ","; + private static final String KEY_VALUE_HOST_INFO_OPENING_MARKER = "("; + private static final String KEY_VALUE_HOST_INFO_CLOSING_MARKER = ")"; + private static final String HOSTS_LIST_OPENING_MARKERS = "[("; + private static final String HOSTS_LIST_CLOSING_MARKERS = "])"; + private static final String ADDRESS_EQUALS_HOST_INFO_PREFIX = "ADDRESS="; + + private static final Pattern CONNECTION_STRING_PTRN = Pattern.compile("(?[\\w\\+:%]+)\\s*" // scheme: required; alphanumeric, plus, colon or percent + + "(?://(?[^/?#]*))?\\s*" // authority: optional; starts with "//" followed by any char except "/", "?" and "#" + + "(?:/(?!\\s*/)(?[^?#]*))?" // path: optional; starts with "/" but not followed by "/", and then followed by by any char except "?" and "#" + + "(?:\\?(?!\\s*\\?)(?[^#]*))?" // query: optional; starts with "?" but not followed by "?", and then followed by by any char except "#" + + "(?:\\s*#(?.*))?"); // fragment: optional; starts with "#", and then followed by anything + private static final Pattern SCHEME_PTRN = Pattern.compile("(?[\\w\\+:%]+).*"); + private static final Pattern HOST_LIST_PTRN = Pattern.compile("^\\[(?.*)\\]$"); + private static final Pattern GENERIC_HOST_PTRN = Pattern.compile("^(?.*?)(?::(?[^:]*))?$"); + private static final Pattern KEY_VALUE_HOST_PTRN = Pattern.compile("[,\\s]*(?[\\w\\.\\-\\s%]*)(?:=(?[^,]*))?"); + private static final Pattern ADDRESS_EQUALS_HOST_PTRN = Pattern.compile("\\s*\\(\\s*(?[\\w\\.\\-%]+)?\\s*(?:=(?[^)]*))?\\)\\s*"); + private static final Pattern PROPERTIES_PTRN = Pattern.compile("[&\\s]*(?[\\w\\.\\-\\s%]*)(?:=(?[^&]*))?"); + + private final String baseConnectionString; + private String scheme; + private String authority; + private String path; + private String query; + + private List parsedHosts = null; + private Map parsedProperties = null; + + /** + * Static factory method for constructing instances of this class. + * + * @param connString + * The connection string to parse. + * @return an instance of {@link ConnectionUrlParser} + */ + public static ConnectionUrlParser parseConnectionString(String connString) { + return new ConnectionUrlParser(connString); + } + + /** + * Constructs a connection string parser for the given connection string. + * + * @param connString + * the connection string to parse + */ + private ConnectionUrlParser(String connString) { + if (connString == null) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("ConnectionString.0")); + } + if (!isConnectionStringSupported(connString)) { + throw ExceptionFactory.createException(UnsupportedConnectionStringException.class, + Messages.getString("ConnectionString.17", new String[] { connString })); + } + this.baseConnectionString = connString; + parseConnectionString(); + } + + /** + * Checks if the scheme part of given connection string matches one of the {@link Type}s supported by Connector/J. + * Throws {@link WrongArgumentException} if connString is null. + * + * @param connString + * connection string + * @return true if supported + */ + public static boolean isConnectionStringSupported(String connString) { + if (connString == null) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("ConnectionString.0")); + } + Matcher matcher = SCHEME_PTRN.matcher(connString); + return matcher.matches() && Type.isSupported(decodeSkippingPlusSign(matcher.group("scheme"))); + } + + /** + * Splits the connection string in its main sections. + */ + private void parseConnectionString() { + String connString = this.baseConnectionString; + Matcher matcher = CONNECTION_STRING_PTRN.matcher(connString); + if (!matcher.matches()) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("ConnectionString.1")); + } + this.scheme = decodeSkippingPlusSign(matcher.group("scheme")); + this.authority = matcher.group("authority"); // Don't decode just yet. + this.path = matcher.group("path") == null ? null : decode(matcher.group("path")).trim(); + this.query = matcher.group("query"); // Don't decode just yet. + } + + /** + * Parses the authority section (user and/or host identification) of the connection string URI. + */ + private void parseAuthoritySection() { + if (isNullOrEmpty(this.authority)) { + // Add an empty, default, host. + this.parsedHosts.add(new HostInfo()); + return; + } + + List authoritySegments = StringUtils.split(this.authority, HOSTS_SEPARATOR, HOSTS_LIST_OPENING_MARKERS, HOSTS_LIST_CLOSING_MARKERS, true, + StringUtils.SEARCH_MODE__MRK_WS); + for (String hi : authoritySegments) { + parseAuthoritySegment(hi); + } + } + + /** + * Parses the given sub authority segment, which can take one of the following syntaxes: + *
    + *
  • _user_:_password_@_host_:_port_ + *
  • _user_:_password_@(key1=value1,key2=value2,...) + *
  • _user_:_password_@address=(key1=value1)(key2=value2)... + *
  • _user_:_password_@[_any_of_the_above_1_,_any_of_the_above_2_,...] + *
+ * Most of the above placeholders can be omitted, representing a null, empty, or default value. + * The placeholder _host_, can be a host name, IPv4 or IPv6. This parser doesn't check IP syntax. IPv6 addresses are enclosed by square brackets ([::1]). + * The placeholder _any_of_the_above_?_ can be any of the above except for the user information part (_user_:_password_@). + * When the symbol ":" is not used, it means an null/empty password or a default (HostInfo.NO_PORT) port, respectively. + * When the symbol "@" is not used, it means that the authority part doesn't contain user information (depending on the scheme type can still be provided + * via key=value pairs). + * + * @param authSegment + * the string containing the authority segment + */ + private void parseAuthoritySegment(String authSegment) { + /* + * Start by splitting the user and host information parts from the authority segment and process the user information, if any. + */ + Pair userHostInfoSplit = splitByUserInfoAndHostInfo(authSegment); + String userInfo = safeTrim(userHostInfoSplit.left); + String user = null; + String password = null; + if (!isNullOrEmpty(userInfo)) { + Pair userInfoPair = parseUserInfo(userInfo); + user = decode(safeTrim(userInfoPair.left)); + password = decode(safeTrim(userInfoPair.right)); + } + String hostInfo = safeTrim(userHostInfoSplit.right); + + /* + * Handle an authority part without host information. + */ + HostInfo hi = buildHostInfoForEmptyHost(user, password, hostInfo); + if (hi != null) { + this.parsedHosts.add(hi); + return; + } + + /* + * Try using a java.net.URI instance to parse the host information. This helps dealing with the IPv6 syntax. + */ + hi = buildHostInfoResortingToUriParser(user, password, authSegment); + if (hi != null) { + this.parsedHosts.add(hi); + return; + } + + /* + * Using a URI didn't work, now check if the host part is composed by a sub list of hosts and process them, one by one if so. + */ + List hiList = buildHostInfoResortingToSubHostsListParser(user, password, hostInfo); + if (hiList != null) { + this.parsedHosts.addAll(hiList); + return; + } + + /* + * The hosts list syntax didn't work, now check if the host information is written in the alternate syntax "(Key1=value1,key2=value2)". + */ + hi = buildHostInfoResortingToKeyValueSyntaxParser(user, password, hostInfo); + if (hi != null) { + this.parsedHosts.add(hi); + return; + } + + /* + * Key/value syntax didn't work either, now check if the host information is written in the alternate syntax "address=(...)". + * This parser needs to run after the key/value one because a key named "address" could invalidate it. + */ + hi = buildHostInfoResortingToAddressEqualsSyntaxParser(user, password, hostInfo); + if (hi != null) { + this.parsedHosts.add(hi); + return; + } + + /* + * Alternate syntax also failed, let's wind up the corner cases the URI couldn't handle. + */ + hi = buildHostInfoResortingToGenericSyntaxParser(user, password, hostInfo); + if (hi != null) { + this.parsedHosts.add(hi); + return; + } + + /* + * Failed parsing the authority segment. + */ + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("ConnectionString.2", new Object[] { authSegment })); + } + + /** + * Builds an {@link HostInfo} instance for empty host authority segments. + * + * @param user + * the user to include in the final {@link HostInfo} + * @param password + * the password to include in the final {@link HostInfo} + * @param hostInfo + * the string containing the host information part + * @return the {@link HostInfo} instance containing the parsed information or null if the host part is not empty + */ + private HostInfo buildHostInfoForEmptyHost(String user, String password, String hostInfo) { + if (isNullOrEmpty(hostInfo)) { + if (isNullOrEmpty(user) && isNullOrEmpty(password)) { + return new HostInfo(); + } + return new HostInfo(this, null, HostInfo.NO_PORT, user, password); + } + return null; + } + + /** + * Parses the host information resorting to a URI object. This process handles most single-host well formed addresses. + * + * @param user + * the user to include in the final {@link HostInfo} + * @param password + * the password to include in the final {@link HostInfo} + * @param hostInfo + * the string containing the host information part + * + * @return the {@link HostInfo} instance containing the parsed information or null if unable to parse the host information + */ + private HostInfo buildHostInfoResortingToUriParser(String user, String password, String hostInfo) { + String host = null; + int port = HostInfo.NO_PORT; + + try { + URI uri = URI.create(DUMMY_SCHEMA + hostInfo); + if (uri.getHost() != null) { + host = decode(uri.getHost()); + } + if (uri.getPort() != -1) { // getPort() returns -1 if the port is undefined. + port = uri.getPort(); + } + if (uri.getUserInfo() != null) { + // Can't have another one. The user information should have been handled already. + return null; + } + } catch (IllegalArgumentException e) { + // The URI failed to parse the host information. + return null; + } + if (host != null || port != HostInfo.NO_PORT) { + // The host info parsing succeeded. + return new HostInfo(this, host, port, user, password); + } + return null; + } + + /** + * Parses the host information using the alternate sub hosts lists syntax "[host1, host2, ...]". + * + * @param user + * the user to include in all the resulting {@link HostInfo} + * @param password + * the password to include in all the resulting {@link HostInfo} + * @param hostInfo + * the string containing the host information part + * @return a list with all {@link HostInfo} instances containing the parsed information or null if unable to parse the host information + */ + private List buildHostInfoResortingToSubHostsListParser(String user, String password, String hostInfo) { + Matcher matcher = HOST_LIST_PTRN.matcher(hostInfo); + if (matcher.matches()) { + String hosts = matcher.group("hosts"); + List hostsList = StringUtils.split(hosts, HOSTS_SEPARATOR, HOSTS_LIST_OPENING_MARKERS, HOSTS_LIST_CLOSING_MARKERS, true, + StringUtils.SEARCH_MODE__MRK_WS); + // One single element could, in fact, be an IPv6 stripped from its delimiters. + boolean maybeIPv6 = hostsList.size() == 1 && hostsList.get(0).matches("(?i)^[\\dabcdef:]+$"); + List hostInfoList = new ArrayList<>(); + for (String h : hostsList) { + HostInfo hi; + if ((hi = buildHostInfoForEmptyHost(user, password, h)) != null) { + hostInfoList.add(hi); + } else if ((hi = buildHostInfoResortingToUriParser(user, password, h)) != null + || (maybeIPv6 && (hi = buildHostInfoResortingToUriParser(user, password, "[" + h + "]")) != null)) { + hostInfoList.add(hi); + } else if ((hi = buildHostInfoResortingToKeyValueSyntaxParser(user, password, h)) != null) { + hostInfoList.add(hi); + } else if ((hi = buildHostInfoResortingToAddressEqualsSyntaxParser(user, password, h)) != null) { + hostInfoList.add(hi); + } else if ((hi = buildHostInfoResortingToGenericSyntaxParser(user, password, h)) != null) { + hostInfoList.add(hi); + } else { + return null; + } + } + return hostInfoList; + } + return null; + } + + /** + * Parses the host information using the alternate syntax "(key1=value1, key2=value2, ...)". + * + * @param user + * the user to include in the resulting {@link HostInfo} + * @param password + * the password to include in the resulting {@link HostInfo} + * @param hostInfo + * the string containing the host information part + * @return the {@link HostInfo} instance containing the parsed information or null if unable to parse the host information + */ + private HostInfo buildHostInfoResortingToKeyValueSyntaxParser(String user, String password, String hostInfo) { + if (!hostInfo.startsWith(KEY_VALUE_HOST_INFO_OPENING_MARKER) || !hostInfo.endsWith(KEY_VALUE_HOST_INFO_CLOSING_MARKER)) { + // This pattern won't work. + return null; + } + hostInfo = hostInfo.substring(KEY_VALUE_HOST_INFO_OPENING_MARKER.length(), hostInfo.length() - KEY_VALUE_HOST_INFO_CLOSING_MARKER.length()); + return new HostInfo(this, null, HostInfo.NO_PORT, user, password, processKeyValuePattern(KEY_VALUE_HOST_PTRN, hostInfo)); + } + + /** + * Parses the host information using the alternate syntax "address=(key1=value1)(key2=value2)...". + * + * @param user + * the user to include in the resulting {@link HostInfo} + * @param password + * the password to include in the resulting {@link HostInfo} + * @param hostInfo + * the string containing the host information part + * @return the {@link HostInfo} instance containing the parsed information or null if unable to parse the host information + */ + private HostInfo buildHostInfoResortingToAddressEqualsSyntaxParser(String user, String password, String hostInfo) { + int p = StringUtils.indexOfIgnoreCase(hostInfo, ADDRESS_EQUALS_HOST_INFO_PREFIX); + if (p != 0) { + // This pattern won't work. + return null; + } + hostInfo = hostInfo.substring(p + ADDRESS_EQUALS_HOST_INFO_PREFIX.length()).trim(); + return new HostInfo(this, null, HostInfo.NO_PORT, user, password, processKeyValuePattern(ADDRESS_EQUALS_HOST_PTRN, hostInfo)); + } + + /** + * Parses the host information using the generic syntax "host:port". + * + * @param user + * the user to include in the resulting {@link HostInfo} + * @param password + * the password to include in the resulting {@link HostInfo} + * @param hostInfo + * the string containing the host information part + * @return the {@link HostInfo} instance containing the parsed information or null if unable to parse the host information + */ + private HostInfo buildHostInfoResortingToGenericSyntaxParser(String user, String password, String hostInfo) { + if (splitByUserInfoAndHostInfo(hostInfo).left != null) { + // This host information is invalid if contains another user information part. + return null; + } + Pair hostPortPair = parseHostPortPair(hostInfo); + String host = decode(safeTrim(hostPortPair.left)); + Integer port = hostPortPair.right; + return new HostInfo(this, isNullOrEmpty(host) ? null : host, port, user, password); + } + + /** + * Splits the given authority segment in the user information part and the host part. + * + * @param authSegment + * the string containing the authority segment, i.e., the user and host information parts + * @return + * a {@link Pair} containing the user information in the left side and the host information in the right + */ + private Pair splitByUserInfoAndHostInfo(String authSegment) { + String userInfoPart = null; + String hostInfoPart = authSegment; + int p = authSegment.indexOf(USER_HOST_SEPARATOR); + if (p >= 0) { + userInfoPart = authSegment.substring(0, p); + hostInfoPart = authSegment.substring(p + USER_HOST_SEPARATOR.length()); + } + return new Pair<>(userInfoPart, hostInfoPart); + } + + /** + * Parses the given user information which is formed by the parts [user][:password]. + * + * @param userInfo + * the string containing the user information + * @return a {@link Pair} containing the user and password information or null if the user information can't be parsed + */ + public static Pair parseUserInfo(String userInfo) { + if (isNullOrEmpty(userInfo)) { + return null; + } + String[] userInfoParts = userInfo.split(USER_PASS_SEPARATOR, 2); + String userName = userInfoParts[0]; + String password = userInfoParts.length > 1 ? userInfoParts[1] : null; + return new Pair<>(userName, password); + } + + /** + * Parses a host:port pair and returns the two elements in a {@link Pair} + * + * @param hostInfo + * the host:pair to parse + * @return a {@link Pair} containing the host and port information or null if the host information can't be parsed + */ + public static Pair parseHostPortPair(String hostInfo) { + if (isNullOrEmpty(hostInfo)) { + return null; + } + Matcher matcher = GENERIC_HOST_PTRN.matcher(hostInfo); + if (matcher.matches()) { + String host = matcher.group("host"); + String portAsString = decode(safeTrim(matcher.group("port"))); + Integer portAsInteger = HostInfo.NO_PORT; + if (!isNullOrEmpty(portAsString)) { + try { + portAsInteger = Integer.parseInt(portAsString); + } catch (NumberFormatException e) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("ConnectionString.3", new Object[] { hostInfo }), + e); + } + } + return new Pair<>(host, portAsInteger); + } + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("ConnectionString.3", new Object[] { hostInfo })); + } + + /** + * Parses the connection properties section and stores the extracted key/value pairs into a local map. + */ + private void parseQuerySection() { + if (isNullOrEmpty(this.query)) { + this.parsedProperties = new HashMap<>(); + return; + } + this.parsedProperties = processKeyValuePattern(PROPERTIES_PTRN, this.query); + } + + /** + * Takes a two-matching-groups (respectively named "key" and "value") pattern which is successively tested against the given string and produces a key/value + * map with the matched values. The given pattern must ensure that there are no leftovers between successive tests, i.e., the end of the previous match must + * coincide with the beginning of the next. + * + * @param pattern + * the regular expression pattern to match against to + * @param input + * the input string + * @return a key/value map containing the matched values + */ + private Map processKeyValuePattern(Pattern pattern, String input) { + Matcher matcher = pattern.matcher(input); + int p = 0; + Map kvMap = new HashMap<>(); + while (matcher.find()) { + if (matcher.start() != p) { + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("ConnectionString.4", new Object[] { input.substring(p) })); + } + String key = decode(safeTrim(matcher.group("key"))); + String value = decode(safeTrim(matcher.group("value"))); + if (!isNullOrEmpty(key)) { + kvMap.put(key, value); + } else if (!isNullOrEmpty(value)) { + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("ConnectionString.4", new Object[] { input.substring(p) })); + } + p = matcher.end(); + } + if (p != input.length()) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("ConnectionString.4", new Object[] { input.substring(p) })); + } + return kvMap; + } + + /** + * URL-decode the given string. + * + * @param text + * the string to decode + * @return + * the decoded string + */ + private static String decode(String text) { + if (isNullOrEmpty(text)) { + return text; + } + try { + return URLDecoder.decode(text, StandardCharsets.UTF_8.name()); + } catch (UnsupportedEncodingException e) { + // Won't happen. + } + return ""; + } + + /** + * URL-decode the given string skipping all occurrences of the plus sign. + * + * @param text + * the string to decode + * @return + * the decoded string + */ + private static String decodeSkippingPlusSign(String text) { + if (isNullOrEmpty(text)) { + return text; + } + text = text.replace("+", "%2B"); // Percent encode for "+" is "%2B". + try { + return URLDecoder.decode(text, StandardCharsets.UTF_8.name()); + } catch (UnsupportedEncodingException e) { + // Won't happen. + } + return ""; + } + + /** + * Returns the original database URL that produced this connection string parser. + * + * @return the original database URL + */ + @Override + public String getDatabaseUrl() { + return this.baseConnectionString; + } + + /** + * Returns the scheme section. + * + * @return the scheme section + */ + public String getScheme() { + return this.scheme; + } + + /** + * Returns the authority section. + * + * @return the authority section + */ + public String getAuthority() { + return this.authority; + } + + /** + * Returns the path section. + * + * @return the path section + */ + public String getPath() { + return this.path; + } + + /** + * Returns the query section. + * + * @return the query section + */ + public String getQuery() { + return this.query; + } + + /** + * Returns the hosts information. + * + * @return the hosts information + */ + public List getHosts() { + if (this.parsedHosts == null) { + this.parsedHosts = new ArrayList<>(); + parseAuthoritySection(); + } + return this.parsedHosts; + } + + /** + * Returns the properties map contained in this connection string. + * + * @return the properties map + */ + public Map getProperties() { + if (this.parsedProperties == null) { + parseQuerySection(); + } + return Collections.unmodifiableMap(this.parsedProperties); + } + + /** + * Returns a string representation of this object. + * + * @return a string representation of this object + */ + @Override + public String toString() { + StringBuilder asStr = new StringBuilder(super.toString()); + asStr.append(String.format(" :: {scheme: \"%s\", authority: \"%s\", path: \"%s\", query: \"%s\", parsedHosts: %s, parsedProperties: %s}", this.scheme, + this.authority, this.path, this.query, this.parsedHosts, this.parsedProperties)); + return asStr.toString(); + } + + /** + * This class is a simple container for two elements. + * + * @param + * left part type + * @param + * right part type + */ + public static class Pair { + public final T left; + public final U right; + + public Pair(T left, U right) { + this.left = left; + this.right = right; + } + + @Override + public String toString() { + StringBuilder asStr = new StringBuilder(super.toString()); + asStr.append(String.format(" :: { left: %s, right: %s }", this.left, this.right)); + return asStr.toString(); + } + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/DatabaseUrlContainer.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/DatabaseUrlContainer.java new file mode 100644 index 0000000..818dd19 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/DatabaseUrlContainer.java @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2016, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +/** + * Implementors of this class must be able to provide a database URL. + */ +public interface DatabaseUrlContainer { + /** + * Returns the original database URL that produced this connection string. + * + * @return the original database URL + */ + String getDatabaseUrl(); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/HostInfo.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/HostInfo.java new file mode 100644 index 0000000..addcb40 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/HostInfo.java @@ -0,0 +1,241 @@ +/* + * Copyright (c) 2016, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +import static com.mysql.cj.util.StringUtils.isNullOrEmpty; + +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.Properties; + +/** + * This class holds the following MySQL host information: + *
    + *
  • host: an IP or host name. + *
  • port: the port number or 0 if not known. + *
  • user: the user name. + *
  • password: the password. + *
  • host properties: host specific connection arguments. + *
+ */ +public class HostInfo implements DatabaseUrlContainer { + public static final int NO_PORT = -1; + private static final String HOST_PORT_SEPARATOR = ":"; + + private final DatabaseUrlContainer originalUrl; + private final String host; + private final int port; + private final String user; + private final String password; + private final Map hostProperties = new HashMap<>(); + + /** + * Constructs an empty {@link HostInfo} instance. + */ + public HostInfo() { + this(null, null, NO_PORT, null, null, null); + } + + /** + * Constructs a {@link HostInfo} instance initialized with the provided host, port and user info. + * + * @param url + * a reference to the original database URL that produced this host info + * @param host + * the host ip or name + * @param port + * the port + * @param user + * the user name + * @param password + * the user's password + */ + public HostInfo(DatabaseUrlContainer url, String host, int port, String user, String password) { + this(url, host, port, user, password, null); + } + + /** + * Constructs a {@link HostInfo} instance initialized with the provided host, port, user, password and connection arguments. + * + * @param url + * a reference to the original database URL that produced this host info + * @param host + * the host ip or name + * @param port + * the port + * @param user + * the user name + * @param password + * this user's password + * @param properties + * a connection arguments map. + */ + public HostInfo(DatabaseUrlContainer url, String host, int port, String user, String password, Map properties) { + this.originalUrl = url; + this.host = host; + this.port = port; + this.user = user; + this.password = password; + if (properties != null) { + this.hostProperties.putAll(properties); + } + } + + /** + * Returns the host. + * + * @return the host + */ + public String getHost() { + return this.host; + } + + /** + * Returns the port. + * + * @return the port + */ + public int getPort() { + return this.port; + } + + /** + * Returns a host:port representation of this host. + * + * @return the host:port representation of this host + */ + public String getHostPortPair() { + return this.host + HOST_PORT_SEPARATOR + this.port; + } + + /** + * Returns the user name. + * + * @return the user name + */ + public String getUser() { + return this.user; + } + + /** + * Returns the password. + * + * @return the password + */ + public String getPassword() { + return this.password; + } + + /** + * Returns the properties specific to this host. + * + * @return this host specific properties + */ + public Map getHostProperties() { + return Collections.unmodifiableMap(this.hostProperties); + } + + /** + * Returns the connection argument for the given key. + * + * @param key + * key + * + * @return the connection argument for the given key + */ + public String getProperty(String key) { + return this.hostProperties.get(key); + } + + /** + * Shortcut to the database connection argument. + * + * @return the database name + */ + public String getDatabase() { + String database = this.hostProperties.get(PropertyKey.DBNAME.getKeyName()); + return isNullOrEmpty(database) ? "" : database; + } + + /** + * Exposes this host info as a single properties instance. The values for host, port, user and password are added to the properties map with their standard + * keys. + * + * @return a {@link Properties} instance containing the full host information. + */ + public Properties exposeAsProperties() { + Properties props = new Properties(); + this.hostProperties.entrySet().stream().forEach(e -> props.setProperty(e.getKey(), e.getValue() == null ? "" : e.getValue())); + props.setProperty(PropertyKey.HOST.getKeyName(), getHost()); + props.setProperty(PropertyKey.PORT.getKeyName(), String.valueOf(getPort())); + if (getUser() != null) { + props.setProperty(PropertyKey.USER.getKeyName(), getUser()); + } + if (getPassword() != null) { + props.setProperty(PropertyKey.PASSWORD.getKeyName(), getPassword()); + } + return props; + } + + /** + * Returns the original database URL that produced this host info. + * + * @return the original database URL + */ + @Override + public String getDatabaseUrl() { + return this.originalUrl != null ? this.originalUrl.getDatabaseUrl() : ""; + } + + /** + * Checks if this {@link HostInfo} has the same host and port pair as the given {@link HostInfo}. + * + * @param hi + * the {@link HostInfo} to compare with. + * @return + * true if both objects have equal host and port pairs, false otherwise. + */ + public boolean equalHostPortPair(HostInfo hi) { + return (getHost() != null && getHost().equals(hi.getHost()) || getHost() == null && hi.getHost() == null) && getPort() == hi.getPort(); + } + + /** + * Returns a string representation of this object. + * + * @return a string representation of this object + */ + @Override + public String toString() { + StringBuilder asStr = new StringBuilder(super.toString()); + asStr.append(String.format(" :: {host: \"%s\", port: %d, hostProperties: %s}", this.host, this.port, this.hostProperties)); + return asStr.toString(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/HostsListView.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/HostsListView.java new file mode 100644 index 0000000..7f7d1d5 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/HostsListView.java @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2019, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +/** + * An enumeration that identifies the type of the view intended for getting hosts lists for multi-host connections. + */ +public enum HostsListView { + ALL, SOURCES, REPLICAS; +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/PropertyDefinition.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/PropertyDefinition.java new file mode 100644 index 0000000..ea36f25 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/PropertyDefinition.java @@ -0,0 +1,160 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +import com.mysql.cj.exceptions.ExceptionInterceptor; + +public interface PropertyDefinition { + + /** + * Does the property have fixed values based constraints. + * + * @return true if property has fixed values based constraints. + */ + boolean hasValueConstraints(); + + /** + * Returns true if property has range-based constraints + * + * @return true if property has range-based constraints + */ + boolean isRangeBased(); + + /** + * Get the property key. + * + * @return {@link PropertyKey} or null if it's a custom property. + */ + PropertyKey getPropertyKey(); + + /** + * Returns the property name. + * + * @return the property name + */ + String getName(); + + /** + * Returns the property camel-case alias. + * + * @return the property camel-case alias. + */ + String getCcAlias(); + + /** + * Returns true if property has a camel-case alias. + * + * @return true if property has a camel-case alias. + */ + boolean hasCcAlias(); + + /** + * Returns the default value. + * + * @return default value + */ + T getDefaultValue(); + + /** + * May the property be changed after initialization. + * + * @return true if the property value may be changed after initialization. + */ + boolean isRuntimeModifiable(); + + /** + * Returns the property description. Used for documentation. + * + * @return property description + */ + String getDescription(); + + /** + * Returns the driver version where the property was introduced first. Used for documentation. + * + * @return the driver version where the property was introduced first + */ + String getSinceVersion(); + + /** + * Returns the property category. + * + * @return property category + */ + String getCategory(); + + /** + * Returns the property order. Used as preferred property position in properties table in documentation. + * + * @return property order + */ + int getOrder(); + + /** + * Returns the list of allowable values. + * + * @return the list of allowable values + */ + String[] getAllowableValues(); + + /** + * The lowest possible value of range-based property + * + * @return the lowest possible value of range-based property + */ + int getLowerBound(); + + /** + * The highest possible value of range-based property + * + * @return the highest possible value of range-based property + */ + int getUpperBound(); + + /** + * Returns the value object parsed from it's string representation and checked against allowable values. + * + * @param value + * value + * @param exceptionInterceptor + * exception interceptor + * + * @return the value object + */ + T parseObject(String value, ExceptionInterceptor exceptionInterceptor); + + /** + * Creates instance of ReadableProperty or ModifiableProperty depending on isRuntimeModifiable() result. + * + * @return {@link RuntimeProperty} instance + */ + RuntimeProperty createRuntimeProperty(); + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/PropertyDefinitions.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/PropertyDefinitions.java new file mode 100644 index 0000000..67b7eb5 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/PropertyDefinitions.java @@ -0,0 +1,879 @@ +/* + * Copyright (c) 2015, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; + +import com.mysql.cj.Messages; +import com.mysql.cj.PerConnectionLRUFactory; +import com.mysql.cj.log.Log; +import com.mysql.cj.log.StandardLogger; +import com.mysql.cj.util.PerVmServerConfigCacheFactory; + +public class PropertyDefinitions { + /* + * Built-in system properties. + */ + public static final String SYSP_line_separator = "line.separator"; + public static final String SYSP_java_vendor = "java.vendor"; + public static final String SYSP_java_version = "java.version"; + public static final String SYSP_java_vm_vendor = "java.vm.vendor"; + public static final String SYSP_os_name = "os.name"; + public static final String SYSP_os_arch = "os.arch"; + public static final String SYSP_os_version = "os.version"; + public static final String SYSP_file_encoding = "file.encoding"; + + /* + * Operational system properties. + */ + public static final String SYSP_disableAbandonedConnectionCleanup = "com.mysql.cj.disableAbandonedConnectionCleanup"; + + /* + * Testsuite system properties. + */ + public static final String SYSP_testsuite_url /* */ = "com.mysql.cj.testsuite.url"; + public final static String SYSP_testsuite_url_admin /* */ = "com.mysql.cj.testsuite.url.admin"; + public static final String SYSP_testsuite_url_cluster /* */ = "com.mysql.cj.testsuite.url.cluster"; + /** Connection string to server compiled with OpenSSL */ + public static final String SYSP_testsuite_url_openssl /* */ = "com.mysql.cj.testsuite.url.openssl"; + + public static final String SYSP_testsuite_url_mysqlx /* */ = "com.mysql.cj.testsuite.mysqlx.url"; + public static final String SYSP_testsuite_url_mysqlx_openssl /* */ = "com.mysql.cj.testsuite.mysqlx.url.openssl"; + + public static final String SYSP_testsuite_cantGrant /* */ = "com.mysql.cj.testsuite.cantGrant"; + public static final String SYSP_testsuite_disable_multihost_tests /* */ = "com.mysql.cj.testsuite.disable.multihost.tests"; // TODO should be more specific for different types of multi-host configs + + public static final String SYSP_testsuite_unavailable_host /* */ = "com.mysql.cj.testsuite.unavailable.host"; + + /** Option to indicate that the server was installed without the test package */ + public static final String SYSP_testsuite_no_server_testsuite /* */ = "com.mysql.cj.testsuite.no.server.testsuite"; + + /** For testsuite.regression.DataSourceRegressionTest */ + public static final String SYSP_testsuite_ds_host /* */ = "com.mysql.cj.testsuite.ds.host"; + /** For testsuite.regression.DataSourceRegressionTest */ + public static final String SYSP_testsuite_ds_port /* */ = "com.mysql.cj.testsuite.ds.port"; + /** For testsuite.regression.DataSourceRegressionTest */ + public static final String SYSP_testsuite_ds_db /* */ = "com.mysql.cj.testsuite.ds.db"; + /** For testsuite.regression.DataSourceRegressionTest */ + public static final String SYSP_testsuite_ds_user /* */ = "com.mysql.cj.testsuite.ds.user"; + /** For testsuite.regression.DataSourceRegressionTest */ + public static final String SYSP_testsuite_ds_password /* */ = "com.mysql.cj.testsuite.ds.password"; + + /** For testsuite.perf.LoadStorePerfTest */ + public static final String SYSP_testsuite_loadstoreperf_tabletype /* */ = "com.mysql.cj.testsuite.loadstoreperf.tabletype"; // TODO document allowed types + /** For testsuite.perf.LoadStorePerfTest */ + public static final String SYSP_testsuite_loadstoreperf_useBigResults /* */ = "com.mysql.cj.testsuite.loadstoreperf.useBigResults"; + + /** The system property that must exist to run the shutdown test in testsuite.simple.MiniAdminTest */ + public static final String SYSP_testsuite_miniAdminTest_runShutdown /* */ = "com.mysql.cj.testsuite.miniAdminTest.runShutdown"; + + /** Suppress debug output when running testsuite */ + public static final String SYSP_testsuite_noDebugOutput /* */ = "com.mysql.cj.testsuite.noDebugOutput"; + /** Don't remove database object created by tests */ + public static final String SYSP_testsuite_retainArtifacts /* */ = "com.mysql.cj.testsuite.retainArtifacts"; + public static final String SYSP_testsuite_runLongTests /* */ = "com.mysql.cj.testsuite.runLongTests"; + public static final String SYSP_testsuite_serverController_basedir /* */ = "com.mysql.cj.testsuite.serverController.basedir"; + + /* + * Build system properties. + */ + public static final String SYSP_com_mysql_cj_build_verbose /* */ = "com.mysql.cj.build.verbose"; + + /* + * Categories of connection properties. + */ + public static final String CATEGORY_AUTH = Messages.getString("ConnectionProperties.categoryAuthentication"); + public static final String CATEGORY_CONNECTION = Messages.getString("ConnectionProperties.categoryConnection"); + public static final String CATEGORY_SESSION = Messages.getString("ConnectionProperties.categorySession"); + public static final String CATEGORY_NETWORK = Messages.getString("ConnectionProperties.categoryNetworking"); + public static final String CATEGORY_SECURITY = Messages.getString("ConnectionProperties.categorySecurity"); + public static final String CATEGORY_STATEMENTS = Messages.getString("ConnectionProperties.categoryStatements"); + public static final String CATEGORY_PREPARED_STATEMENTS = Messages.getString("ConnectionProperties.categoryPreparedStatements"); + public static final String CATEGORY_RESULT_SETS = Messages.getString("ConnectionProperties.categoryResultSets"); + public static final String CATEGORY_METADATA = Messages.getString("ConnectionProperties.categoryMetadata"); + public static final String CATEGORY_BLOBS = Messages.getString("ConnectionProperties.categoryBlobs"); + public static final String CATEGORY_DATETIMES = Messages.getString("ConnectionProperties.categoryDatetimes"); + public static final String CATEGORY_HA = Messages.getString("ConnectionProperties.categoryHA"); + public static final String CATEGORY_PERFORMANCE = Messages.getString("ConnectionProperties.categoryPerformance"); + public static final String CATEGORY_DEBUGING_PROFILING = Messages.getString("ConnectionProperties.categoryDebuggingProfiling"); + public static final String CATEGORY_EXCEPTIONS = Messages.getString("ConnectionProperties.categoryExceptions"); + public static final String CATEGORY_INTEGRATION = Messages.getString("ConnectionProperties.categoryIntegration"); + public static final String CATEGORY_JDBC = Messages.getString("ConnectionProperties.categoryJDBC"); + public static final String CATEGORY_XDEVAPI = Messages.getString("ConnectionProperties.categoryXDevAPI"); + public static final String CATEGORY_USER_DEFINED = Messages.getString("ConnectionProperties.categoryUserDefined"); + + public static final String[] PROPERTY_CATEGORIES = new String[] { CATEGORY_AUTH, CATEGORY_CONNECTION, CATEGORY_SESSION, CATEGORY_NETWORK, CATEGORY_SECURITY, + CATEGORY_STATEMENTS, CATEGORY_PREPARED_STATEMENTS, CATEGORY_RESULT_SETS, CATEGORY_METADATA, CATEGORY_BLOBS, CATEGORY_DATETIMES, CATEGORY_HA, + CATEGORY_PERFORMANCE, CATEGORY_DEBUGING_PROFILING, CATEGORY_EXCEPTIONS, CATEGORY_INTEGRATION, CATEGORY_JDBC, CATEGORY_XDEVAPI }; + + /* + * Property modifiers. + */ + public static final boolean DEFAULT_VALUE_TRUE = true; + public static final boolean DEFAULT_VALUE_FALSE = false; + public static final String DEFAULT_VALUE_NULL_STRING = null; + public static final String NO_ALIAS = null; + + /** is modifiable in run-time */ + public static final boolean RUNTIME_MODIFIABLE = true; + + /** is not modifiable in run-time (will allow to set not-null value only once) */ + public static final boolean RUNTIME_NOT_MODIFIABLE = false; + + /* + * Property enums. + */ + public enum ZeroDatetimeBehavior { // zeroDateTimeBehavior + CONVERT_TO_NULL, EXCEPTION, ROUND; + } + + public enum SslMode { + PREFERRED, REQUIRED, VERIFY_CA, VERIFY_IDENTITY, DISABLED; + } + + public enum XdevapiSslMode { + REQUIRED, VERIFY_CA, VERIFY_IDENTITY, DISABLED; + } + + public enum AuthMech { // xdevapi.auth + PLAIN, MYSQL41, SHA256_MEMORY, EXTERNAL; + } + + public enum Compression { // xdevapi.compress + PREFERRED, REQUIRED, DISABLED; + } + + public enum DatabaseTerm { + CATALOG, SCHEMA; + } + + /** + * Static unmodifiable {@link PropertyKey} -> {@link PropertyDefinition} map. + */ + public static final Map> PROPERTY_KEY_TO_PROPERTY_DEFINITION; + + static { + String STANDARD_LOGGER_NAME = StandardLogger.class.getName(); + + PropertyDefinition[] pdefs = new PropertyDefinition[] { + // + // CATEGORY_AUTHENTICATION + // + new StringPropertyDefinition(PropertyKey.USER, DEFAULT_VALUE_NULL_STRING, RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.Username"), Messages.getString("ConnectionProperties.allVersions"), CATEGORY_AUTH, + Integer.MIN_VALUE + 1), + + new StringPropertyDefinition(PropertyKey.PASSWORD, DEFAULT_VALUE_NULL_STRING, RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.Password"), Messages.getString("ConnectionProperties.allVersions"), CATEGORY_AUTH, + Integer.MIN_VALUE + 2), + + new StringPropertyDefinition(PropertyKey.authenticationPlugins, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.authenticationPlugins"), "5.1.19", CATEGORY_AUTH, Integer.MIN_VALUE + 3), + + new StringPropertyDefinition(PropertyKey.disabledAuthenticationPlugins, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.disabledAuthenticationPlugins"), "5.1.19", CATEGORY_AUTH, Integer.MIN_VALUE + 4), + + new StringPropertyDefinition(PropertyKey.defaultAuthenticationPlugin, "mysql_native_password", RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.defaultAuthenticationPlugin"), "5.1.19", CATEGORY_AUTH, Integer.MIN_VALUE + 5), + + new StringPropertyDefinition(PropertyKey.ldapServerHostname, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.ldapServerHostname"), "8.0.23", CATEGORY_AUTH, Integer.MIN_VALUE + 6), + + // + // CATEGORY_CONNECTION + // + new StringPropertyDefinition(PropertyKey.passwordCharacterEncoding, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.passwordCharacterEncoding"), "5.1.7", CATEGORY_CONNECTION, Integer.MIN_VALUE), + + new StringPropertyDefinition(PropertyKey.connectionAttributes, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.connectionAttributes"), "5.1.25", CATEGORY_CONNECTION, 7), + + new StringPropertyDefinition(PropertyKey.clientInfoProvider, "com.mysql.cj.jdbc.CommentClientInfoProvider", RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.clientInfoProvider"), "5.1.0", CATEGORY_CONNECTION, Integer.MIN_VALUE), + + new StringPropertyDefinition(PropertyKey.connectionLifecycleInterceptors, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.connectionLifecycleInterceptors"), "5.1.4", CATEGORY_CONNECTION, Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.createDatabaseIfNotExist, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.createDatabaseIfNotExist"), "3.1.9", CATEGORY_CONNECTION, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.interactiveClient, DEFAULT_VALUE_FALSE, RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.interactiveClient"), "3.1.0", CATEGORY_CONNECTION, Integer.MIN_VALUE), + + new StringPropertyDefinition(PropertyKey.propertiesTransform, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.connectionPropertiesTransform"), "3.1.4", CATEGORY_CONNECTION, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.rollbackOnPooledClose, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.rollbackOnPooledClose"), "3.0.15", CATEGORY_CONNECTION, Integer.MIN_VALUE), + + new StringPropertyDefinition(PropertyKey.useConfigs, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.useConfigs"), "3.1.5", CATEGORY_CONNECTION, Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.useAffectedRows, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.useAffectedRows"), "5.1.7", CATEGORY_CONNECTION, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.disconnectOnExpiredPasswords, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.disconnectOnExpiredPasswords"), "5.1.23", CATEGORY_CONNECTION, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.detectCustomCollations, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.detectCustomCollations"), "5.1.29", CATEGORY_CONNECTION, Integer.MIN_VALUE), + + new EnumPropertyDefinition<>(PropertyKey.databaseTerm, DatabaseTerm.CATALOG, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.databaseTerm"), "8.0.17", CATEGORY_CONNECTION, Integer.MIN_VALUE), + + // + // CATEGORY_SESSION + // + new StringPropertyDefinition(PropertyKey.characterEncoding, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.characterEncoding"), "1.1g", CATEGORY_SESSION, Integer.MIN_VALUE), + + new StringPropertyDefinition(PropertyKey.characterSetResults, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.characterSetResults"), "3.0.13", CATEGORY_SESSION, Integer.MIN_VALUE), + + new StringPropertyDefinition(PropertyKey.customCharsetMapping, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.customCharsetMapping"), "8.0.26", CATEGORY_SESSION, Integer.MIN_VALUE), + + new StringPropertyDefinition(PropertyKey.connectionCollation, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.connectionCollation"), "3.0.13", CATEGORY_SESSION, Integer.MIN_VALUE), + + new StringPropertyDefinition(PropertyKey.sessionVariables, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.sessionVariables"), "3.1.8", CATEGORY_SESSION, Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.trackSessionState, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.trackSessionState"), "8.0.26", CATEGORY_SESSION, Integer.MIN_VALUE), + + // + // CATEGORY_NETWORK + // + new BooleanPropertyDefinition(PropertyKey.useUnbufferedInput, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.useUnbufferedInput"), "3.0.11", CATEGORY_NETWORK, Integer.MIN_VALUE), + + new IntegerPropertyDefinition(PropertyKey.connectTimeout, 0, RUNTIME_MODIFIABLE, Messages.getString("ConnectionProperties.connectTimeout"), + "3.0.1", CATEGORY_NETWORK, 9, 0, Integer.MAX_VALUE), + + new StringPropertyDefinition(PropertyKey.localSocketAddress, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.localSocketAddress"), "5.0.5", CATEGORY_NETWORK, Integer.MIN_VALUE), + + new StringPropertyDefinition(PropertyKey.socketFactory, "com.mysql.cj.protocol.StandardSocketFactory", RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.socketFactory"), "3.0.3", CATEGORY_NETWORK, 4), + + new StringPropertyDefinition(PropertyKey.socksProxyHost, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.socksProxyHost"), "5.1.34", CATEGORY_NETWORK, 1), + + new IntegerPropertyDefinition(PropertyKey.socksProxyPort, 1080, RUNTIME_MODIFIABLE, Messages.getString("ConnectionProperties.socksProxyPort"), + "5.1.34", CATEGORY_NETWORK, 2, 0, 65535), + + new IntegerPropertyDefinition(PropertyKey.socketTimeout, 0, RUNTIME_MODIFIABLE, Messages.getString("ConnectionProperties.socketTimeout"), + "3.0.1", CATEGORY_NETWORK, 10, 0, Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.tcpNoDelay, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.tcpNoDelay"), "5.0.7", CATEGORY_NETWORK, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.tcpKeepAlive, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.tcpKeepAlive"), "5.0.7", CATEGORY_NETWORK, Integer.MIN_VALUE), + + new IntegerPropertyDefinition(PropertyKey.tcpRcvBuf, 0, RUNTIME_MODIFIABLE, Messages.getString("ConnectionProperties.tcpSoRcvBuf"), "5.0.7", + CATEGORY_NETWORK, Integer.MIN_VALUE, 0, Integer.MAX_VALUE), + + new IntegerPropertyDefinition(PropertyKey.tcpSndBuf, 0, RUNTIME_MODIFIABLE, Messages.getString("ConnectionProperties.tcpSoSndBuf"), "5.0.7", + CATEGORY_NETWORK, Integer.MIN_VALUE, 0, Integer.MAX_VALUE), + + new IntegerPropertyDefinition(PropertyKey.tcpTrafficClass, 0, RUNTIME_MODIFIABLE, Messages.getString("ConnectionProperties.tcpTrafficClass"), + "5.0.7", CATEGORY_NETWORK, Integer.MIN_VALUE, 0, 255), + + new BooleanPropertyDefinition(PropertyKey.useCompression, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.useCompression"), "3.0.17", CATEGORY_NETWORK, Integer.MIN_VALUE), + + new IntegerPropertyDefinition(PropertyKey.maxAllowedPacket, 65535, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.maxAllowedPacket"), "5.1.8", CATEGORY_NETWORK, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.dnsSrv, DEFAULT_VALUE_FALSE, RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.dnsSrv"), "8.0.19", CATEGORY_NETWORK, Integer.MIN_VALUE), + + // + // CATEGORY_SECURITY + // + new BooleanPropertyDefinition(PropertyKey.paranoid, DEFAULT_VALUE_FALSE, RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.paranoid"), "3.0.1", CATEGORY_SECURITY, 1), + + new StringPropertyDefinition(PropertyKey.serverRSAPublicKeyFile, DEFAULT_VALUE_NULL_STRING, RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.serverRSAPublicKeyFile"), "5.1.31", CATEGORY_SECURITY, 2), + + new BooleanPropertyDefinition(PropertyKey.allowPublicKeyRetrieval, DEFAULT_VALUE_FALSE, RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.allowPublicKeyRetrieval"), "5.1.31", CATEGORY_SECURITY, 3), + + new EnumPropertyDefinition<>(PropertyKey.sslMode, SslMode.PREFERRED, RUNTIME_MODIFIABLE, Messages.getString("ConnectionProperties.sslMode"), + "8.0.13", CATEGORY_SECURITY, 4), + + new StringPropertyDefinition(PropertyKey.trustCertificateKeyStoreUrl, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.trustCertificateKeyStoreUrl"), "5.1.0", CATEGORY_SECURITY, 5), + + new StringPropertyDefinition(PropertyKey.trustCertificateKeyStoreType, "JKS", RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.trustCertificateKeyStoreType"), "5.1.0", CATEGORY_SECURITY, 6), + + new StringPropertyDefinition(PropertyKey.trustCertificateKeyStorePassword, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.trustCertificateKeyStorePassword"), "5.1.0", CATEGORY_SECURITY, 7), + + new BooleanPropertyDefinition(PropertyKey.fallbackToSystemTrustStore, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.fallbackToSystemTrustStore"), "8.0.22", CATEGORY_SECURITY, 8), + + new StringPropertyDefinition(PropertyKey.clientCertificateKeyStoreUrl, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.clientCertificateKeyStoreUrl"), "5.1.0", CATEGORY_SECURITY, 9), + + new StringPropertyDefinition(PropertyKey.clientCertificateKeyStoreType, "JKS", RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.clientCertificateKeyStoreType"), "5.1.0", CATEGORY_SECURITY, 10), + + new StringPropertyDefinition(PropertyKey.clientCertificateKeyStorePassword, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.clientCertificateKeyStorePassword"), "5.1.0", CATEGORY_SECURITY, 11), + + new BooleanPropertyDefinition(PropertyKey.fallbackToSystemKeyStore, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.fallbackToSystemKeyStore"), "8.0.22", CATEGORY_SECURITY, 12), + + new StringPropertyDefinition(PropertyKey.enabledSSLCipherSuites, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.enabledSSLCipherSuites"), "5.1.35", CATEGORY_SECURITY, 13), + + new StringPropertyDefinition(PropertyKey.enabledTLSProtocols, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.enabledTLSProtocols"), "8.0.8", CATEGORY_SECURITY, 14), + + new BooleanPropertyDefinition(PropertyKey.allowLoadLocalInfile, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.loadDataLocal"), "3.0.3", CATEGORY_SECURITY, Integer.MAX_VALUE), + + new StringPropertyDefinition(PropertyKey.allowLoadLocalInfileInPath, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.loadDataLocalInPath"), "8.0.22", CATEGORY_SECURITY, Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.allowMultiQueries, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.allowMultiQueries"), "3.1.1", CATEGORY_SECURITY, Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.allowUrlInLocalInfile, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.allowUrlInLoadLocal"), "3.1.4", CATEGORY_SECURITY, Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.useSSL, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, Messages.getString("ConnectionProperties.useSSL"), + "3.0.2", CATEGORY_SECURITY, Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.requireSSL, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.requireSSL"), "3.1.0", CATEGORY_SECURITY, Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.verifyServerCertificate, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.verifyServerCertificate"), "5.1.6", CATEGORY_SECURITY, Integer.MAX_VALUE), + + // + // CATEGORY_STATEMENTS + // + new BooleanPropertyDefinition(PropertyKey.continueBatchOnError, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.continueBatchOnError"), "3.0.3", CATEGORY_STATEMENTS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.dontTrackOpenResources, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.dontTrackOpenResources"), "3.1.7", CATEGORY_STATEMENTS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.queryTimeoutKillsConnection, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.queryTimeoutKillsConnection"), "5.1.9", CATEGORY_STATEMENTS, Integer.MIN_VALUE), + + new StringPropertyDefinition(PropertyKey.queryInterceptors, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.queryInterceptors"), "8.0.7", CATEGORY_STATEMENTS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.cacheDefaultTimeZone, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.cacheDefaultTimeZone"), "8.0.20", CATEGORY_STATEMENTS, Integer.MIN_VALUE), + + // + // CATEGORY_PREPARED_STATEMENTS + // + new BooleanPropertyDefinition(PropertyKey.allowNanAndInf, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.allowNANandINF"), "3.1.5", CATEGORY_PREPARED_STATEMENTS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.autoClosePStmtStreams, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.autoClosePstmtStreams"), "3.1.12", CATEGORY_PREPARED_STATEMENTS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.compensateOnDuplicateKeyUpdateCounts, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.compensateOnDuplicateKeyUpdateCounts"), "5.1.7", CATEGORY_PREPARED_STATEMENTS, + Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.useServerPrepStmts, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.useServerPrepStmts"), "3.1.0", CATEGORY_PREPARED_STATEMENTS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.emulateUnsupportedPstmts, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.emulateUnsupportedPstmts"), "3.1.7", CATEGORY_PREPARED_STATEMENTS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.generateSimpleParameterMetadata, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.generateSimpleParameterMetadata"), "5.0.5", CATEGORY_PREPARED_STATEMENTS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.processEscapeCodesForPrepStmts, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.processEscapeCodesForPrepStmts"), "3.1.12", CATEGORY_PREPARED_STATEMENTS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.useStreamLengthsInPrepStmts, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.useStreamLengthsInPrepStmts"), "3.0.2", CATEGORY_PREPARED_STATEMENTS, Integer.MIN_VALUE), + + // + // CATEGORY_RESULT_SETS + // + new BooleanPropertyDefinition(PropertyKey.clobberStreamingResults, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.clobberStreamingResults"), "3.0.9", CATEGORY_RESULT_SETS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.emptyStringsConvertToZero, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.emptyStringsConvertToZero"), "3.1.8", CATEGORY_RESULT_SETS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.holdResultsOpenOverStatementClose, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.holdRSOpenOverStmtClose"), "3.1.7", CATEGORY_RESULT_SETS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.jdbcCompliantTruncation, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.jdbcCompliantTruncation"), "3.1.2", CATEGORY_RESULT_SETS, Integer.MIN_VALUE), + + new IntegerPropertyDefinition(PropertyKey.maxRows, -1, RUNTIME_MODIFIABLE, Messages.getString("ConnectionProperties.maxRows"), + Messages.getString("ConnectionProperties.allVersions"), CATEGORY_RESULT_SETS, Integer.MIN_VALUE, -1, Integer.MAX_VALUE), + + new IntegerPropertyDefinition(PropertyKey.netTimeoutForStreamingResults, 600, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.netTimeoutForStreamingResults"), "5.1.0", CATEGORY_RESULT_SETS, Integer.MIN_VALUE, 0, + Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.padCharsWithSpace, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.padCharsWithSpace"), "5.0.6", CATEGORY_RESULT_SETS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.populateInsertRowWithDefaultValues, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.populateInsertRowWithDefaultValues"), "5.0.5", CATEGORY_RESULT_SETS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.strictUpdates, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.strictUpdates"), "3.0.4", CATEGORY_RESULT_SETS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.tinyInt1isBit, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.tinyInt1isBit"), "3.0.16", CATEGORY_RESULT_SETS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.transformedBitIsBoolean, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.transformedBitIsBoolean"), "3.1.9", CATEGORY_RESULT_SETS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.scrollTolerantForwardOnly, DEFAULT_VALUE_FALSE, RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.scrollTolerantForwardOnly"), "8.0.24", CATEGORY_RESULT_SETS, Integer.MIN_VALUE), + + // + // CATEGORY_METADATA + // + new BooleanPropertyDefinition(PropertyKey.noAccessToProcedureBodies, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.noAccessToProcedureBodies"), "5.0.3", CATEGORY_METADATA, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.nullDatabaseMeansCurrent, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.nullCatalogMeansCurrent"), "3.1.8", CATEGORY_METADATA, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.useHostsInPrivileges, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.useHostsInPrivileges"), "3.0.2", CATEGORY_METADATA, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.useInformationSchema, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.useInformationSchema"), "5.0.0", CATEGORY_METADATA, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.getProceduresReturnsFunctions, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.getProceduresReturnsFunctions"), "5.1.26", CATEGORY_METADATA, Integer.MIN_VALUE), + + // + // CATEGORY_BLOBS + // + new BooleanPropertyDefinition(PropertyKey.autoDeserialize, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.autoDeserialize"), "3.1.5", CATEGORY_BLOBS, Integer.MIN_VALUE), + + new MemorySizePropertyDefinition(PropertyKey.blobSendChunkSize, 1024 * 1024, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.blobSendChunkSize"), "3.1.9", CATEGORY_BLOBS, Integer.MIN_VALUE, 0, 0), + + new BooleanPropertyDefinition(PropertyKey.blobsAreStrings, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.blobsAreStrings"), "5.0.8", CATEGORY_BLOBS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.functionsNeverReturnBlobs, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.functionsNeverReturnBlobs"), "5.0.8", CATEGORY_BLOBS, Integer.MIN_VALUE), + + new StringPropertyDefinition(PropertyKey.clobCharacterEncoding, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.clobCharacterEncoding"), "5.0.0", CATEGORY_BLOBS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.emulateLocators, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.emulateLocators"), "3.1.0", CATEGORY_BLOBS, Integer.MIN_VALUE), + + new MemorySizePropertyDefinition(PropertyKey.locatorFetchBufferSize, 1024 * 1024, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.locatorFetchBufferSize"), "3.2.1", CATEGORY_BLOBS, Integer.MIN_VALUE, 0, Integer.MAX_VALUE), + + // + // CATEGORY_DATETIMES + // + new BooleanPropertyDefinition(PropertyKey.noDatetimeStringSync, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.noDatetimeStringSync"), "3.1.7", CATEGORY_DATETIMES, Integer.MIN_VALUE), + + new StringPropertyDefinition(PropertyKey.connectionTimeZone, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.connectionTimeZone"), "3.0.2", CATEGORY_DATETIMES, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.forceConnectionTimeZoneToSession, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.forceConnectionTimeZoneToSession"), "8.0.23", CATEGORY_DATETIMES, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.preserveInstants, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.preserveInstants"), "8.0.23", CATEGORY_DATETIMES, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.treatUtilDateAsTimestamp, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.treatUtilDateAsTimestamp"), "5.0.5", CATEGORY_DATETIMES, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.sendFractionalSeconds, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.sendFractionalSeconds"), "5.1.37", CATEGORY_DATETIMES, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.sendFractionalSecondsForTime, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.sendFractionalSecondsForTime"), "8.0.23", CATEGORY_DATETIMES, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.yearIsDateType, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.yearIsDateType"), "3.1.9", CATEGORY_DATETIMES, Integer.MIN_VALUE), + + new EnumPropertyDefinition<>(PropertyKey.zeroDateTimeBehavior, ZeroDatetimeBehavior.EXCEPTION, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.zeroDateTimeBehavior", + new Object[] { ZeroDatetimeBehavior.EXCEPTION, ZeroDatetimeBehavior.ROUND, ZeroDatetimeBehavior.CONVERT_TO_NULL }), + "3.1.4", CATEGORY_DATETIMES, Integer.MIN_VALUE), + + // + // CATEGORY_HA + // + new BooleanPropertyDefinition(PropertyKey.allowSourceDownConnections, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.allowSourceDownConnections"), "5.1.27", CATEGORY_HA, Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.allowReplicaDownConnections, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.allowReplicaDownConnections"), "6.0.2", CATEGORY_HA, Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.readFromSourceWhenNoReplicas, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.readFromSourceWhenNoReplicas"), "6.0.2", CATEGORY_HA, Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.autoReconnect, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.autoReconnect"), "1.1", CATEGORY_HA, 0), + + new BooleanPropertyDefinition(PropertyKey.autoReconnectForPools, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.autoReconnectForPools"), "3.1.3", CATEGORY_HA, 1), + + new BooleanPropertyDefinition(PropertyKey.failOverReadOnly, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.failoverReadOnly"), "3.0.12", CATEGORY_HA, 2), + + new IntegerPropertyDefinition(PropertyKey.initialTimeout, 2, RUNTIME_NOT_MODIFIABLE, Messages.getString("ConnectionProperties.initialTimeout"), + "1.1", CATEGORY_HA, 5, 1, Integer.MAX_VALUE), + + new StringPropertyDefinition(PropertyKey.ha_loadBalanceStrategy, "random", RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.loadBalanceStrategy"), "5.0.6", CATEGORY_HA, Integer.MIN_VALUE), + + new IntegerPropertyDefinition(PropertyKey.loadBalanceBlocklistTimeout, 0, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.loadBalanceBlocklistTimeout"), "5.1.0", CATEGORY_HA, Integer.MIN_VALUE, 0, Integer.MAX_VALUE), + + new IntegerPropertyDefinition(PropertyKey.loadBalancePingTimeout, 0, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.loadBalancePingTimeout"), "5.1.13", CATEGORY_HA, Integer.MIN_VALUE, 0, Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.loadBalanceValidateConnectionOnSwapServer, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.loadBalanceValidateConnectionOnSwapServer"), "5.1.13", CATEGORY_HA, Integer.MIN_VALUE), + + new StringPropertyDefinition(PropertyKey.loadBalanceConnectionGroup, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.loadBalanceConnectionGroup"), "5.1.13", CATEGORY_HA, Integer.MIN_VALUE), + + new StringPropertyDefinition(PropertyKey.loadBalanceExceptionChecker, "com.mysql.cj.jdbc.ha.StandardLoadBalanceExceptionChecker", + RUNTIME_MODIFIABLE, Messages.getString("ConnectionProperties.loadBalanceExceptionChecker"), "5.1.13", CATEGORY_HA, Integer.MIN_VALUE), + + new StringPropertyDefinition(PropertyKey.loadBalanceSQLStateFailover, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.loadBalanceSQLStateFailover"), "5.1.13", CATEGORY_HA, Integer.MIN_VALUE), + + new StringPropertyDefinition(PropertyKey.loadBalanceSQLExceptionSubclassFailover, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.loadBalanceSQLExceptionSubclassFailover"), "5.1.13", CATEGORY_HA, Integer.MIN_VALUE), + + new StringPropertyDefinition(PropertyKey.loadBalanceAutoCommitStatementRegex, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.loadBalanceAutoCommitStatementRegex"), "5.1.15", CATEGORY_HA, Integer.MIN_VALUE), + + new IntegerPropertyDefinition(PropertyKey.loadBalanceAutoCommitStatementThreshold, 0, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.loadBalanceAutoCommitStatementThreshold"), "5.1.15", CATEGORY_HA, Integer.MIN_VALUE, 0, + Integer.MAX_VALUE), + + new IntegerPropertyDefinition(PropertyKey.maxReconnects, 3, RUNTIME_MODIFIABLE, Messages.getString("ConnectionProperties.maxReconnects"), "1.1", + CATEGORY_HA, 4, 1, Integer.MAX_VALUE), + + new IntegerPropertyDefinition(PropertyKey.retriesAllDown, 120, RUNTIME_MODIFIABLE, Messages.getString("ConnectionProperties.retriesAllDown"), + "5.1.6", CATEGORY_HA, 4, 0, Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.pinGlobalTxToPhysicalConnection, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.pinGlobalTxToPhysicalConnection"), "5.0.1", CATEGORY_HA, Integer.MIN_VALUE), + + new IntegerPropertyDefinition(PropertyKey.queriesBeforeRetrySource, 50, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.queriesBeforeRetrySource"), "3.0.2", CATEGORY_HA, 7, 0, Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.reconnectAtTxEnd, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.reconnectAtTxEnd"), "3.0.10", CATEGORY_HA, 4), + + new StringPropertyDefinition(PropertyKey.replicationConnectionGroup, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.replicationConnectionGroup"), "8.0.7", CATEGORY_HA, Integer.MIN_VALUE), + + new StringPropertyDefinition(PropertyKey.resourceId, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.resourceId"), "5.0.1", CATEGORY_HA, Integer.MIN_VALUE), + + new IntegerPropertyDefinition(PropertyKey.secondsBeforeRetrySource, 30, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.secondsBeforeRetrySource"), "3.0.2", CATEGORY_HA, 8, 0, Integer.MAX_VALUE), + + new IntegerPropertyDefinition(PropertyKey.selfDestructOnPingSecondsLifetime, 0, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.selfDestructOnPingSecondsLifetime"), "5.1.6", CATEGORY_HA, Integer.MAX_VALUE, 0, + Integer.MAX_VALUE), + + new IntegerPropertyDefinition(PropertyKey.selfDestructOnPingMaxOperations, 0, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.selfDestructOnPingMaxOperations"), "5.1.6", CATEGORY_HA, Integer.MAX_VALUE, 0, + Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.ha_enableJMX, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.ha.enableJMX"), "5.1.27", CATEGORY_HA, Integer.MAX_VALUE), + + new IntegerPropertyDefinition(PropertyKey.loadBalanceHostRemovalGracePeriod, 15000, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.loadBalanceHostRemovalGracePeriod"), "6.0.3", CATEGORY_HA, Integer.MAX_VALUE, 0, + Integer.MAX_VALUE), + + new StringPropertyDefinition(PropertyKey.serverAffinityOrder, DEFAULT_VALUE_NULL_STRING, RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.serverAffinityOrder"), "8.0.8", CATEGORY_HA, Integer.MIN_VALUE), + + // + // CATEGORY_PERFORMANCE + // + new BooleanPropertyDefinition(PropertyKey.alwaysSendSetIsolation, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.alwaysSendSetIsolation"), "3.1.7", CATEGORY_PERFORMANCE, Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.cacheCallableStmts, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.cacheCallableStatements"), "3.1.2", CATEGORY_PERFORMANCE, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.cachePrepStmts, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.cachePrepStmts"), "3.0.10", CATEGORY_PERFORMANCE, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.cacheResultSetMetadata, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.cacheRSMetadata"), "3.1.1", CATEGORY_PERFORMANCE, Integer.MIN_VALUE), + + new StringPropertyDefinition(PropertyKey.serverConfigCacheFactory, PerVmServerConfigCacheFactory.class.getName(), RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.serverConfigCacheFactory"), "5.1.1", CATEGORY_PERFORMANCE, 12), + + new BooleanPropertyDefinition(PropertyKey.cacheServerConfiguration, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.cacheServerConfiguration"), "3.1.5", CATEGORY_PERFORMANCE, Integer.MIN_VALUE), + + new IntegerPropertyDefinition(PropertyKey.callableStmtCacheSize, 100, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.callableStmtCacheSize"), "3.1.2", CATEGORY_PERFORMANCE, 5, 0, Integer.MAX_VALUE), + + new IntegerPropertyDefinition(PropertyKey.defaultFetchSize, 0, RUNTIME_MODIFIABLE, Messages.getString("ConnectionProperties.defaultFetchSize"), + "3.1.9", CATEGORY_PERFORMANCE, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.elideSetAutoCommits, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.eliseSetAutoCommit"), "3.1.3", CATEGORY_PERFORMANCE, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.enableQueryTimeouts, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.enableQueryTimeouts"), "5.0.6", CATEGORY_PERFORMANCE, Integer.MIN_VALUE), + + new MemorySizePropertyDefinition(PropertyKey.largeRowSizeThreshold, 2048, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.largeRowSizeThreshold"), "5.1.1", CATEGORY_PERFORMANCE, Integer.MIN_VALUE, 0, + Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.maintainTimeStats, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.maintainTimeStats"), "3.1.9", CATEGORY_PERFORMANCE, Integer.MAX_VALUE), + + new IntegerPropertyDefinition(PropertyKey.metadataCacheSize, 50, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.metadataCacheSize"), "3.1.1", CATEGORY_PERFORMANCE, 5, 1, Integer.MAX_VALUE), + + new IntegerPropertyDefinition(PropertyKey.prepStmtCacheSize, 25, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.prepStmtCacheSize"), "3.0.10", CATEGORY_PERFORMANCE, 10, 0, Integer.MAX_VALUE), + + new IntegerPropertyDefinition(PropertyKey.prepStmtCacheSqlLimit, 256, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.prepStmtCacheSqlLimit"), "3.0.10", CATEGORY_PERFORMANCE, 11, 1, Integer.MAX_VALUE), + + new StringPropertyDefinition(PropertyKey.parseInfoCacheFactory, PerConnectionLRUFactory.class.getName(), RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.parseInfoCacheFactory"), "5.1.1", CATEGORY_PERFORMANCE, 12), + + new BooleanPropertyDefinition(PropertyKey.rewriteBatchedStatements, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.rewriteBatchedStatements"), "3.1.13", CATEGORY_PERFORMANCE, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.useCursorFetch, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.useCursorFetch"), "5.0.0", CATEGORY_PERFORMANCE, Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.useLocalSessionState, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.useLocalSessionState"), "3.1.7", CATEGORY_PERFORMANCE, 5), + + new BooleanPropertyDefinition(PropertyKey.useLocalTransactionState, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.useLocalTransactionState"), "5.1.7", CATEGORY_PERFORMANCE, 6), + + new BooleanPropertyDefinition(PropertyKey.useReadAheadInput, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.useReadAheadInput"), "3.1.5", CATEGORY_PERFORMANCE, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.dontCheckOnDuplicateKeyUpdateInSQL, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.dontCheckOnDuplicateKeyUpdateInSQL"), "5.1.32", CATEGORY_PERFORMANCE, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.readOnlyPropagatesToServer, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.readOnlyPropagatesToServer"), "5.1.35", CATEGORY_PERFORMANCE, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.enableEscapeProcessing, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.enableEscapeProcessing"), "6.0.1", CATEGORY_PERFORMANCE, Integer.MIN_VALUE), + + // + // CATEGORY_DEBUGING_PROFILING + // + new StringPropertyDefinition(PropertyKey.logger, STANDARD_LOGGER_NAME, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.logger", new Object[] { Log.class.getName(), STANDARD_LOGGER_NAME }), "3.1.1", + CATEGORY_DEBUGING_PROFILING, 0), + + new StringPropertyDefinition(PropertyKey.profilerEventHandler, "com.mysql.cj.log.LoggingProfilerEventHandler", RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.profilerEventHandler"), "5.1.6", CATEGORY_DEBUGING_PROFILING, 1), + + new BooleanPropertyDefinition(PropertyKey.useNanosForElapsedTime, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.useNanosForElapsedTime"), "5.0.7", CATEGORY_DEBUGING_PROFILING, 2), + + new IntegerPropertyDefinition(PropertyKey.maxQuerySizeToLog, 2048, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.maxQuerySizeToLog"), "3.1.3", CATEGORY_DEBUGING_PROFILING, 3, 0, Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.profileSQL, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.profileSQL"), "3.1.0", CATEGORY_DEBUGING_PROFILING, 4), + + new BooleanPropertyDefinition(PropertyKey.logSlowQueries, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.logSlowQueries"), "3.1.2", CATEGORY_DEBUGING_PROFILING, 5), + + new IntegerPropertyDefinition(PropertyKey.slowQueryThresholdMillis, 2000, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.slowQueryThresholdMillis"), "3.1.2", CATEGORY_DEBUGING_PROFILING, 6, 0, Integer.MAX_VALUE), + + new LongPropertyDefinition(PropertyKey.slowQueryThresholdNanos, 0, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.slowQueryThresholdNanos"), "5.0.7", CATEGORY_DEBUGING_PROFILING, 7), + + new BooleanPropertyDefinition(PropertyKey.autoSlowLog, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.autoSlowLog"), "5.1.4", CATEGORY_DEBUGING_PROFILING, 8), + + new BooleanPropertyDefinition(PropertyKey.explainSlowQueries, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.explainSlowQueries"), "3.1.2", CATEGORY_DEBUGING_PROFILING, 9), + + new BooleanPropertyDefinition(PropertyKey.gatherPerfMetrics, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.gatherPerfMetrics"), "3.1.2", CATEGORY_DEBUGING_PROFILING, 10), + + new IntegerPropertyDefinition(PropertyKey.reportMetricsIntervalMillis, 30000, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.reportMetricsIntervalMillis"), "3.1.2", CATEGORY_DEBUGING_PROFILING, 11, 0, Integer.MAX_VALUE), // TODO currently is not used !!! + + new BooleanPropertyDefinition(PropertyKey.logXaCommands, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.logXaCommands"), "5.0.5", CATEGORY_DEBUGING_PROFILING, 12), + + new BooleanPropertyDefinition(PropertyKey.traceProtocol, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.traceProtocol"), "3.1.2", CATEGORY_DEBUGING_PROFILING, 13), + + new BooleanPropertyDefinition(PropertyKey.enablePacketDebug, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.enablePacketDebug"), "3.1.3", CATEGORY_DEBUGING_PROFILING, 14), + + new IntegerPropertyDefinition(PropertyKey.packetDebugBufferSize, 20, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.packetDebugBufferSize"), "3.1.3", CATEGORY_DEBUGING_PROFILING, 15, 1, Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.useUsageAdvisor, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.useUsageAdvisor"), "3.1.1", CATEGORY_DEBUGING_PROFILING, 16), + + new IntegerPropertyDefinition(PropertyKey.resultSetSizeThreshold, 100, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.resultSetSizeThreshold"), "5.0.5", CATEGORY_DEBUGING_PROFILING, 17), + + new BooleanPropertyDefinition(PropertyKey.autoGenerateTestcaseScript, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.autoGenerateTestcaseScript"), "3.1.9", CATEGORY_DEBUGING_PROFILING, 18), + + // + // CATEGORY_EXCEPTIONS + // + new BooleanPropertyDefinition(PropertyKey.dumpQueriesOnException, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.dumpQueriesOnException"), "3.1.3", CATEGORY_EXCEPTIONS, Integer.MIN_VALUE), + + new StringPropertyDefinition(PropertyKey.exceptionInterceptors, DEFAULT_VALUE_NULL_STRING, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.exceptionInterceptors"), "5.1.8", CATEGORY_EXCEPTIONS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.includeInnodbStatusInDeadlockExceptions, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.includeInnodbStatusInDeadlockExceptions"), "5.0.7", CATEGORY_EXCEPTIONS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.includeThreadDumpInDeadlockExceptions, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.includeThreadDumpInDeadlockExceptions"), "5.1.15", CATEGORY_EXCEPTIONS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.includeThreadNamesAsStatementComment, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.includeThreadNamesAsStatementComment"), "5.1.15", CATEGORY_EXCEPTIONS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.ignoreNonTxTables, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.ignoreNonTxTables"), "3.0.9", CATEGORY_EXCEPTIONS, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.useOnlyServerErrorMessages, DEFAULT_VALUE_TRUE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.useOnlyServerErrorMessages"), "3.0.15", CATEGORY_EXCEPTIONS, Integer.MIN_VALUE), + + // + // CATEGORY_INTEGRATION + // + new BooleanPropertyDefinition(PropertyKey.overrideSupportsIntegrityEnhancementFacility, false, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.overrideSupportsIEF"), "3.1.12", CATEGORY_INTEGRATION, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.ultraDevHack, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.ultraDevHack"), "2.0.3", CATEGORY_INTEGRATION, Integer.MIN_VALUE), + + // + // CATEGORY_JDBC + // + new BooleanPropertyDefinition(PropertyKey.pedantic, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.pedantic"), "3.0.0", CATEGORY_JDBC, Integer.MIN_VALUE), + + new BooleanPropertyDefinition(PropertyKey.useColumnNamesInFindColumn, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.useColumnNamesInFindColumn"), "5.1.7", CATEGORY_JDBC, Integer.MAX_VALUE), + + new BooleanPropertyDefinition(PropertyKey.useOldAliasMetadataBehavior, DEFAULT_VALUE_FALSE, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.useOldAliasMetadataBehavior"), "5.0.4", CATEGORY_JDBC, Integer.MIN_VALUE), + + // + // CATEGORY_XDEVAPI + // + new EnumPropertyDefinition<>(PropertyKey.xdevapiSslMode, XdevapiSslMode.REQUIRED, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.xdevapiSslMode"), "8.0.7", CATEGORY_XDEVAPI, Integer.MIN_VALUE), + new StringPropertyDefinition(PropertyKey.xdevapiTlsCiphersuites, DEFAULT_VALUE_NULL_STRING, RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.xdevapiTlsCiphersuites"), "8.0.19", CATEGORY_XDEVAPI, Integer.MIN_VALUE), + new StringPropertyDefinition(PropertyKey.xdevapiTlsVersions, DEFAULT_VALUE_NULL_STRING, RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.xdevapiTlsVersions"), "8.0.19", CATEGORY_XDEVAPI, Integer.MIN_VALUE), + new StringPropertyDefinition(PropertyKey.xdevapiSslKeyStoreUrl, DEFAULT_VALUE_NULL_STRING, RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.xdevapiSslKeyStoreUrl"), "8.0.22", CATEGORY_XDEVAPI, Integer.MIN_VALUE), + new StringPropertyDefinition(PropertyKey.xdevapiSslKeyStorePassword, DEFAULT_VALUE_NULL_STRING, RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.xdevapiSslKeyStorePassword"), "8.0.22", CATEGORY_XDEVAPI, Integer.MIN_VALUE), + new StringPropertyDefinition(PropertyKey.xdevapiSslKeyStoreType, "JKS", RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.xdevapiSslKeyStoreType"), "8.0.22", CATEGORY_XDEVAPI, Integer.MIN_VALUE), + new BooleanPropertyDefinition(PropertyKey.xdevapiFallbackToSystemKeyStore, DEFAULT_VALUE_TRUE, RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.xdevapiFallbackToSystemKeyStore"), "8.0.22", CATEGORY_XDEVAPI, Integer.MIN_VALUE), + new StringPropertyDefinition(PropertyKey.xdevapiSslTrustStoreUrl, DEFAULT_VALUE_NULL_STRING, RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.xdevapiSslTrustStoreUrl"), "6.0.6", CATEGORY_XDEVAPI, Integer.MIN_VALUE), + new StringPropertyDefinition(PropertyKey.xdevapiSslTrustStorePassword, DEFAULT_VALUE_NULL_STRING, RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.xdevapiSslTrustStorePassword"), "6.0.6", CATEGORY_XDEVAPI, Integer.MIN_VALUE), + new StringPropertyDefinition(PropertyKey.xdevapiSslTrustStoreType, "JKS", RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.xdevapiSslTrustStoreType"), "6.0.6", CATEGORY_XDEVAPI, Integer.MIN_VALUE), + new BooleanPropertyDefinition(PropertyKey.xdevapiFallbackToSystemTrustStore, DEFAULT_VALUE_TRUE, RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.xdevapiFallbackToSystemTrustStore"), "8.0.22", CATEGORY_XDEVAPI, Integer.MIN_VALUE), + new EnumPropertyDefinition<>(PropertyKey.xdevapiAuth, AuthMech.PLAIN, RUNTIME_NOT_MODIFIABLE, Messages.getString("ConnectionProperties.auth"), + "8.0.8", CATEGORY_XDEVAPI, Integer.MIN_VALUE), + new IntegerPropertyDefinition(PropertyKey.xdevapiConnectTimeout, 10000, RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.xdevapiConnectTimeout"), "8.0.13", CATEGORY_XDEVAPI, Integer.MIN_VALUE, 0, Integer.MAX_VALUE), + new StringPropertyDefinition(PropertyKey.xdevapiConnectionAttributes, DEFAULT_VALUE_NULL_STRING, RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.xdevapiConnectionAttributes"), "8.0.16", CATEGORY_XDEVAPI, Integer.MIN_VALUE), + new BooleanPropertyDefinition(PropertyKey.xdevapiDnsSrv, DEFAULT_VALUE_FALSE, RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.xdevapiDnsSrv"), "8.0.19", CATEGORY_XDEVAPI, Integer.MIN_VALUE), + new EnumPropertyDefinition<>(PropertyKey.xdevapiCompression, Compression.PREFERRED, RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.xdevapiCompression"), "8.0.20", CATEGORY_XDEVAPI, Integer.MIN_VALUE), + new StringPropertyDefinition(PropertyKey.xdevapiCompressionAlgorithms, "zstd_stream,lz4_message,deflate_stream", RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.xdevapiCompressionAlgorithms"), "8.0.22", CATEGORY_XDEVAPI, Integer.MIN_VALUE), + new StringPropertyDefinition(PropertyKey.xdevapiCompressionExtensions, DEFAULT_VALUE_NULL_STRING, RUNTIME_NOT_MODIFIABLE, + Messages.getString("ConnectionProperties.xdevapiCompressionExtensions"), "8.0.22", CATEGORY_XDEVAPI, Integer.MIN_VALUE) + // + }; + + HashMap> propertyKeyToPropertyDefinitionMap = new HashMap<>(); + for (PropertyDefinition pdef : pdefs) { + propertyKeyToPropertyDefinitionMap.put(pdef.getPropertyKey(), pdef); + } + PROPERTY_KEY_TO_PROPERTY_DEFINITION = Collections.unmodifiableMap(propertyKeyToPropertyDefinitionMap); + } + + public static PropertyDefinition getPropertyDefinition(PropertyKey propertyKey) { + return PROPERTY_KEY_TO_PROPERTY_DEFINITION.get(propertyKey); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/PropertyKey.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/PropertyKey.java new file mode 100644 index 0000000..8bd8457 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/PropertyKey.java @@ -0,0 +1,382 @@ +/* + * Copyright (c) 2018, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +import java.util.Map; +import java.util.TreeMap; + +/** + * PropertyKey handles connection property names, their camel-case aliases and case sensitivity. + */ +public enum PropertyKey { + /* + * Properties individually managed after parsing connection string. These property keys are case insensitive. + */ + /** The database user name. */ + USER("user", false), + /** The database user password. */ + PASSWORD("password", false), + /** The hostname value from the properties instance passed to the driver. */ + HOST("host", false), + /** The port number value from the properties instance passed to the driver. */ + PORT("port", false), + /** The communications protocol. Possible values: "tcp" and "pipe". */ + PROTOCOL("protocol", false), + /** The name pipes path to use when "protocol=pipe'. */ + PATH("path", "namedPipePath", false), + /** The server type in a replication setup. Possible values: "source" and "replica". */ + TYPE("type", false), + /** The address value ("host:port") from the properties instance passed to the driver. */ + ADDRESS("address", false), + /** The host priority in a list of hosts. */ + PRIORITY("priority", false), + /** The database value from the properties instance passed to the driver. */ + DBNAME("dbname", false), // + + allowLoadLocalInfile("allowLoadLocalInfile", true), // + allowLoadLocalInfileInPath("allowLoadLocalInfileInPath", true), // + allowSourceDownConnections("allowSourceDownConnections", "allowMasterDownConnections", true), // + allowMultiQueries("allowMultiQueries", true), // + allowNanAndInf("allowNanAndInf", true), // + allowPublicKeyRetrieval("allowPublicKeyRetrieval", true), // + allowReplicaDownConnections("allowReplicaDownConnections", "allowSlaveDownConnections", true), // + allowUrlInLocalInfile("allowUrlInLocalInfile", true), // + alwaysSendSetIsolation("alwaysSendSetIsolation", true), // + authenticationPlugins("authenticationPlugins", true), // + autoClosePStmtStreams("autoClosePStmtStreams", true), // + autoDeserialize("autoDeserialize", true), // + autoGenerateTestcaseScript("autoGenerateTestcaseScript", true), // + autoReconnect("autoReconnect", true), // + autoReconnectForPools("autoReconnectForPools", true), // + autoSlowLog("autoSlowLog", true), // + blobsAreStrings("blobsAreStrings", true), // + blobSendChunkSize("blobSendChunkSize", true), // + cacheCallableStmts("cacheCallableStmts", true), // + cacheDefaultTimeZone("cacheDefaultTimeZone", "cacheDefaultTimezone", true), // + cachePrepStmts("cachePrepStmts", true), // + cacheResultSetMetadata("cacheResultSetMetadata", true), // + cacheServerConfiguration("cacheServerConfiguration", true), // + callableStmtCacheSize("callableStmtCacheSize", true), // + characterEncoding("characterEncoding", true), // + characterSetResults("characterSetResults", true), // + clientCertificateKeyStorePassword("clientCertificateKeyStorePassword", true), // + clientCertificateKeyStoreType("clientCertificateKeyStoreType", true), // + clientCertificateKeyStoreUrl("clientCertificateKeyStoreUrl", true), // + clientInfoProvider("clientInfoProvider", true), // + clobberStreamingResults("clobberStreamingResults", true), // + clobCharacterEncoding("clobCharacterEncoding", true), // + compensateOnDuplicateKeyUpdateCounts("compensateOnDuplicateKeyUpdateCounts", true), // + connectionAttributes("connectionAttributes", true), // + connectionCollation("connectionCollation", true), // + connectionLifecycleInterceptors("connectionLifecycleInterceptors", true), // + connectionTimeZone("connectionTimeZone", "serverTimezone", true), // + connectTimeout("connectTimeout", true), // + continueBatchOnError("continueBatchOnError", true), // + createDatabaseIfNotExist("createDatabaseIfNotExist", true), // + customCharsetMapping("customCharsetMapping", true), // + databaseTerm("databaseTerm", true), // + defaultAuthenticationPlugin("defaultAuthenticationPlugin", true), // + defaultFetchSize("defaultFetchSize", true), // + detectCustomCollations("detectCustomCollations", true), // + disabledAuthenticationPlugins("disabledAuthenticationPlugins", true), // + disconnectOnExpiredPasswords("disconnectOnExpiredPasswords", true), // + dnsSrv("dnsSrv", true), // + dontCheckOnDuplicateKeyUpdateInSQL("dontCheckOnDuplicateKeyUpdateInSQL", true), // + dontTrackOpenResources("dontTrackOpenResources", true), // + dumpQueriesOnException("dumpQueriesOnException", true), // + elideSetAutoCommits("elideSetAutoCommits", true), // + emptyStringsConvertToZero("emptyStringsConvertToZero", true), // + emulateLocators("emulateLocators", true), // + emulateUnsupportedPstmts("emulateUnsupportedPstmts", true), // + enabledSSLCipherSuites("enabledSSLCipherSuites", true), // + enabledTLSProtocols("enabledTLSProtocols", true), // + enableEscapeProcessing("enableEscapeProcessing", true), // + enablePacketDebug("enablePacketDebug", true), // + enableQueryTimeouts("enableQueryTimeouts", true), // + exceptionInterceptors("exceptionInterceptors", true), // + explainSlowQueries("explainSlowQueries", true), // + failOverReadOnly("failOverReadOnly", true), // + fallbackToSystemKeyStore("fallbackToSystemKeyStore", true), // + fallbackToSystemTrustStore("fallbackToSystemTrustStore", true), // + functionsNeverReturnBlobs("functionsNeverReturnBlobs", true), // + gatherPerfMetrics("gatherPerfMetrics", true), // + generateSimpleParameterMetadata("generateSimpleParameterMetadata", true), // + getProceduresReturnsFunctions("getProceduresReturnsFunctions", true), // + holdResultsOpenOverStatementClose("holdResultsOpenOverStatementClose", true), // + ha_enableJMX("ha.enableJMX", "haEnableJMX", true), // + ha_loadBalanceStrategy("ha.loadBalanceStrategy", "haLoadBalanceStrategy", true), // + ignoreNonTxTables("ignoreNonTxTables", true), // + includeInnodbStatusInDeadlockExceptions("includeInnodbStatusInDeadlockExceptions", true), // + includeThreadDumpInDeadlockExceptions("includeThreadDumpInDeadlockExceptions", true), // + includeThreadNamesAsStatementComment("includeThreadNamesAsStatementComment", true), // + initialTimeout("initialTimeout", true), // + interactiveClient("interactiveClient", true), // + jdbcCompliantTruncation("jdbcCompliantTruncation", true), // + largeRowSizeThreshold("largeRowSizeThreshold", true), // + ldapServerHostname("ldapServerHostname", true), // + loadBalanceAutoCommitStatementRegex("loadBalanceAutoCommitStatementRegex", true), // + loadBalanceAutoCommitStatementThreshold("loadBalanceAutoCommitStatementThreshold", true), // + loadBalanceBlocklistTimeout("loadBalanceBlocklistTimeout", "loadBalanceBlacklistTimeout", true), // + loadBalanceConnectionGroup("loadBalanceConnectionGroup", true), // + loadBalanceExceptionChecker("loadBalanceExceptionChecker", true), // + loadBalanceHostRemovalGracePeriod("loadBalanceHostRemovalGracePeriod", true), // + loadBalancePingTimeout("loadBalancePingTimeout", true), // + loadBalanceSQLStateFailover("loadBalanceSQLStateFailover", true), // + loadBalanceSQLExceptionSubclassFailover("loadBalanceSQLExceptionSubclassFailover", true), // + loadBalanceValidateConnectionOnSwapServer("loadBalanceValidateConnectionOnSwapServer", true), // + localSocketAddress("localSocketAddress", true), // + locatorFetchBufferSize("locatorFetchBufferSize", true), // + logger("logger", true), // + logSlowQueries("logSlowQueries", true), // + logXaCommands("logXaCommands", true), // + maintainTimeStats("maintainTimeStats", true), // + maxAllowedPacket("maxAllowedPacket", true), // + maxQuerySizeToLog("maxQuerySizeToLog", true), // + maxReconnects("maxReconnects", true), // + maxRows("maxRows", true), // + metadataCacheSize("metadataCacheSize", true), // + netTimeoutForStreamingResults("netTimeoutForStreamingResults", true), // + noAccessToProcedureBodies("noAccessToProcedureBodies", true), // + noDatetimeStringSync("noDatetimeStringSync", true), // + nullDatabaseMeansCurrent("nullDatabaseMeansCurrent", "nullCatalogMeansCurrent", true), // + overrideSupportsIntegrityEnhancementFacility("overrideSupportsIntegrityEnhancementFacility", true), // + packetDebugBufferSize("packetDebugBufferSize", true), // + padCharsWithSpace("padCharsWithSpace", true), // + paranoid("paranoid", false), // + parseInfoCacheFactory("parseInfoCacheFactory", true), // + passwordCharacterEncoding("passwordCharacterEncoding", true), // + pedantic("pedantic", true), // + pinGlobalTxToPhysicalConnection("pinGlobalTxToPhysicalConnection", true), // + populateInsertRowWithDefaultValues("populateInsertRowWithDefaultValues", true), // + prepStmtCacheSize("prepStmtCacheSize", true), // + prepStmtCacheSqlLimit("prepStmtCacheSqlLimit", true), // + preserveInstants("preserveInstants", true), // + processEscapeCodesForPrepStmts("processEscapeCodesForPrepStmts", true), // + profilerEventHandler("profilerEventHandler", true), // + profileSQL("profileSQL", true), // + forceConnectionTimeZoneToSession("forceConnectionTimeZoneToSession", true), // + propertiesTransform("propertiesTransform", true), // + queriesBeforeRetrySource("queriesBeforeRetrySource", "queriesBeforeRetryMaster", true), // + queryInterceptors("queryInterceptors", true), // + queryTimeoutKillsConnection("queryTimeoutKillsConnection", true), // + readFromSourceWhenNoReplicas("readFromSourceWhenNoReplicas", "readFromMasterWhenNoSlaves", true), // + readOnlyPropagatesToServer("readOnlyPropagatesToServer", true), // + reconnectAtTxEnd("reconnectAtTxEnd", true), // + replicationConnectionGroup("replicationConnectionGroup", true), // + reportMetricsIntervalMillis("reportMetricsIntervalMillis", true), // + requireSSL("requireSSL", true), // + resourceId("resourceId", true), // + resultSetSizeThreshold("resultSetSizeThreshold", true), // + retriesAllDown("retriesAllDown", true), // + rewriteBatchedStatements("rewriteBatchedStatements", true), // + rollbackOnPooledClose("rollbackOnPooledClose", true), // + scrollTolerantForwardOnly("scrollTolerantForwardOnly", true), // + secondsBeforeRetrySource("secondsBeforeRetrySource", "secondsBeforeRetryMaster", true), // + selfDestructOnPingMaxOperations("selfDestructOnPingMaxOperations", true), // + selfDestructOnPingSecondsLifetime("selfDestructOnPingSecondsLifetime", true), // + sendFractionalSeconds("sendFractionalSeconds", true), // + sendFractionalSecondsForTime("sendFractionalSecondsForTime", true), // + serverAffinityOrder("serverAffinityOrder", true), // + serverConfigCacheFactory("serverConfigCacheFactory", true), // + serverRSAPublicKeyFile("serverRSAPublicKeyFile", true), // + sessionVariables("sessionVariables", true), // + trackSessionState("trackSessionState", true), // + slowQueryThresholdMillis("slowQueryThresholdMillis", true), // + slowQueryThresholdNanos("slowQueryThresholdNanos", true), // + socketFactory("socketFactory", true), // + socketTimeout("socketTimeout", true), // + socksProxyHost("socksProxyHost", true), // + socksProxyPort("socksProxyPort", true), // + sslMode("sslMode", true), // + strictUpdates("strictUpdates", true), // + tcpKeepAlive("tcpKeepAlive", true), // + tcpNoDelay("tcpNoDelay", true), // + tcpRcvBuf("tcpRcvBuf", true), // + tcpSndBuf("tcpSndBuf", true), // + tcpTrafficClass("tcpTrafficClass", true), // + tinyInt1isBit("tinyInt1isBit", true), // + traceProtocol("traceProtocol", true), // + transformedBitIsBoolean("transformedBitIsBoolean", true), // + treatUtilDateAsTimestamp("treatUtilDateAsTimestamp", true), // + trustCertificateKeyStorePassword("trustCertificateKeyStorePassword", true), // + trustCertificateKeyStoreType("trustCertificateKeyStoreType", true), // + trustCertificateKeyStoreUrl("trustCertificateKeyStoreUrl", true), // + ultraDevHack("ultraDevHack", true), // + useAffectedRows("useAffectedRows", true), // + useColumnNamesInFindColumn("useColumnNamesInFindColumn", true), // + useCompression("useCompression", true), // + useConfigs("useConfigs", true), // + useCursorFetch("useCursorFetch", true), // + useHostsInPrivileges("useHostsInPrivileges", true), // + useInformationSchema("useInformationSchema", true), // + useLocalSessionState("useLocalSessionState", true), // + useLocalTransactionState("useLocalTransactionState", true), // + useNanosForElapsedTime("useNanosForElapsedTime", true), // + useOldAliasMetadataBehavior("useOldAliasMetadataBehavior", true), // + useOnlyServerErrorMessages("useOnlyServerErrorMessages", true), // + useReadAheadInput("useReadAheadInput", true), // + useServerPrepStmts("useServerPrepStmts", true), // + useSSL("useSSL", true), // + useStreamLengthsInPrepStmts("useStreamLengthsInPrepStmts", true), // + useUnbufferedInput("useUnbufferedInput", true), // + useUsageAdvisor("useUsageAdvisor", true), // + verifyServerCertificate("verifyServerCertificate", true), // + + xdevapiAsyncResponseTimeout("xdevapi.asyncResponseTimeout", "xdevapiAsyncResponseTimeout", true), // + xdevapiAuth("xdevapi.auth", "xdevapiAuth", true), // + xdevapiConnectTimeout("xdevapi.connect-timeout", "xdevapiConnectTimeout", true), // + xdevapiConnectionAttributes("xdevapi.connection-attributes", "xdevapiConnectionAttributes", true), // + xdevapiCompression("xdevapi.compression", "xdevapiCompression", true), // + xdevapiCompressionAlgorithms("xdevapi.compression-algorithms", "xdevapiCompressionAlgorithms", true), // + xdevapiCompressionExtensions("xdevapi.compression-extensions", "xdevapiCompressionExtensions", true), // + xdevapiDnsSrv("xdevapi.dns-srv", "xdevapiDnsSrv", true), // + xdevapiFallbackToSystemKeyStore("xdevapi.fallback-to-system-keystore", "xdevapiFallbackToSystemKeyStore", true), // + xdevapiFallbackToSystemTrustStore("xdevapi.fallback-to-system-truststore", "xdevapiFallbackToSystemTrustStore", true), // + xdevapiSslKeyStorePassword("xdevapi.ssl-keystore-password", "xdevapiSslKeystorePassword", true), // + xdevapiSslKeyStoreType("xdevapi.ssl-keystore-type", "xdevapiSslKeystoreType", true), // + xdevapiSslKeyStoreUrl("xdevapi.ssl-keystore", "xdevapiSslKeystore", true), // + xdevapiSslMode("xdevapi.ssl-mode", "xdevapiSslMode", true), // + xdevapiSslTrustStorePassword("xdevapi.ssl-truststore-password", "xdevapiSslTruststorePassword", true), // + xdevapiSslTrustStoreType("xdevapi.ssl-truststore-type", "xdevapiSslTruststoreType", true), // + xdevapiSslTrustStoreUrl("xdevapi.ssl-truststore", "xdevapiSslTruststore", true), // + xdevapiTlsCiphersuites("xdevapi.tls-ciphersuites", "xdevapiTlsCiphersuites", true), // + xdevapiTlsVersions("xdevapi.tls-versions", "xdevapiTlsVersions", true), // + xdevapiUseAsyncProtocol("xdevapi.useAsyncProtocol", "xdevapiUseAsyncProtocol", true), // + + yearIsDateType("yearIsDateType", true), // + zeroDateTimeBehavior("zeroDateTimeBehavior", true) // + ; + + private String keyName; + private String ccAlias = null; + private boolean isCaseSensitive = false; + + private static Map caseInsensitiveValues = new TreeMap<>(String.CASE_INSENSITIVE_ORDER); + static { + for (PropertyKey pk : values()) { + if (!pk.isCaseSensitive) { + caseInsensitiveValues.put(pk.getKeyName(), pk); + if (pk.getCcAlias() != null) { + caseInsensitiveValues.put(pk.getCcAlias(), pk); + } + } + } + } + + /** + * Initializes each enum element with the proper key name to be used in the connection string or properties maps. + * + * @param keyName + * the key name for the enum element. + * @param isCaseSensitive + * is this name case sensitive + */ + PropertyKey(String keyName, boolean isCaseSensitive) { + this.keyName = keyName; + this.isCaseSensitive = isCaseSensitive; + } + + /** + * Initializes each enum element with the proper key name to be used in the connection string or properties maps. + * + * @param keyName + * the key name for the enum element. + * @param alias + * camel-case alias key name + * @param isCaseSensitive + * is this name case sensitive + */ + PropertyKey(String keyName, String alias, boolean isCaseSensitive) { + this(keyName, isCaseSensitive); + this.ccAlias = alias; + } + + @Override + public String toString() { + return this.keyName; + } + + /** + * Gets the key name of this enum element. + * + * @return + * the key name associated with the enum element. + */ + public String getKeyName() { + return this.keyName; + } + + /** + * Gets the camel-case alias key name of this enum element. + * + * @return + * the camel-case alias key name associated with the enum element or null. + */ + public String getCcAlias() { + return this.ccAlias; + } + + /** + * Looks for a {@link PropertyKey} that matches the given value as key name. + * + * @param value + * the key name to look for. + * @return + * the {@link PropertyKey} element that matches the given key name value or null if none is found. + */ + public static PropertyKey fromValue(String value) { + for (PropertyKey k : values()) { + if (k.isCaseSensitive) { + if (k.getKeyName().equals(value) || (k.getCcAlias() != null && k.getCcAlias().equals(value))) { + return k; + } + } else { + if (k.getKeyName().equalsIgnoreCase(value) || (k.getCcAlias() != null && k.getCcAlias().equalsIgnoreCase(value))) { + return k; + } + } + } + return null; + } + + /** + * Helper method that normalizes the case of the given key, if it is one of {@link PropertyKey} elements. + * + * @param keyName + * the key name to normalize. + * @return + * the normalized key name if it belongs to this enum, otherwise returns the input unchanged. + */ + public static String normalizeCase(String keyName) { + PropertyKey pk = caseInsensitiveValues.get(keyName); + return pk == null ? keyName : pk.getKeyName(); + //return keyName; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/PropertySet.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/PropertySet.java new file mode 100644 index 0000000..b5d8724 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/PropertySet.java @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +import java.util.Properties; + +public interface PropertySet { + + void addProperty(RuntimeProperty prop); + + void removeProperty(String name); + + void removeProperty(PropertyKey key); + + RuntimeProperty getProperty(String name); + + RuntimeProperty getProperty(PropertyKey key); + + RuntimeProperty getBooleanProperty(String name); + + RuntimeProperty getBooleanProperty(PropertyKey key); + + RuntimeProperty getIntegerProperty(String name); + + RuntimeProperty getIntegerProperty(PropertyKey key); + + RuntimeProperty getLongProperty(String name); + + RuntimeProperty getLongProperty(PropertyKey key); + + RuntimeProperty getMemorySizeProperty(String name); + + RuntimeProperty getMemorySizeProperty(PropertyKey key); + + RuntimeProperty getStringProperty(String name); + + RuntimeProperty getStringProperty(PropertyKey key); + + > RuntimeProperty getEnumProperty(String name); + + > RuntimeProperty getEnumProperty(PropertyKey key); + + /** + * Initializes the property set with driver properties that come from URL or passed to + * the driver manager. + * + * @param props + * properties + */ + void initializeProperties(Properties props); + + void postInitialization(); + + Properties exposeAsProperties(); + + /** + * Reset all properties to their initial values. + */ + void reset(); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/RuntimeProperty.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/RuntimeProperty.java new file mode 100644 index 0000000..38aa2dd --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/conf/RuntimeProperty.java @@ -0,0 +1,120 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +import java.util.Properties; + +import javax.naming.Reference; + +import com.mysql.cj.exceptions.ExceptionInterceptor; + +public interface RuntimeProperty { + + PropertyDefinition getPropertyDefinition(); + + /** + * Explicitly set value of this RuntimeProperty according to the self-titled property value contained in extractFrom. + * This method is called during PropertySet initialization thus ignores the RUNTIME_NOT_MODIFIABLE flag. + *

+ * This value will also be the initial one, i.e. {@link #resetValue()} will reset to this value, not the default one. + *

+ * If extractFrom does not contain such property then this RuntimeProperty remains unchanged. + * + * @param extractFrom + * {@link Properties} object containing key-value pairs usually passed from connection string. + * @param exceptionInterceptor + * exceptionInterceptor + */ + void initializeFrom(Properties extractFrom, ExceptionInterceptor exceptionInterceptor); + + void initializeFrom(Reference ref, ExceptionInterceptor exceptionInterceptor); + + /** + * Reset to initial value (default or defined in connection string/Properties) + */ + void resetValue(); + + boolean isExplicitlySet(); + + /** + * Add listener for this property changes. + * + * @param l + * {@link RuntimePropertyListener} + */ + void addListener(RuntimePropertyListener l); + + void removeListener(RuntimePropertyListener l); + + @FunctionalInterface + public static interface RuntimePropertyListener { + void handlePropertyChange(RuntimeProperty prop); + } + + /** + * Get internal value representation as Object. + * + * @return value + */ + T getValue(); + + /** + * Get initial value (default or defined in connection string/Properties) + * + * @return value + */ + T getInitialValue(); + + /** + * Get internal value representation as String. + * + * @return value + */ + String getStringValue(); + + /** + * Set the object value of a property directly. Validation against allowable values will be performed. + * + * @param value + * value + */ + void setValue(T value); + + /** + * Set the object value of a property directly. Validation against allowable values will be performed. + * + * @param value + * value + * @param exceptionInterceptor + * exception interceptor + */ + void setValue(T value, ExceptionInterceptor exceptionInterceptor); + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/AssertionFailedException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/AssertionFailedException.java new file mode 100644 index 0000000..bb7093f --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/AssertionFailedException.java @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +import com.mysql.cj.Messages; + +/** + * Assertions for empty code paths that should never be executed. + */ +public class AssertionFailedException extends CJException { + + private static final long serialVersionUID = 5832552608575043403L; + + /** + * Convenience method. + * + * @param ex + * the exception that should never have been thrown. + * @return {@link AssertionFailedException} + * @throws AssertionFailedException + * for the exception ex. + */ + public static AssertionFailedException shouldNotHappen(Exception ex) throws AssertionFailedException { + throw new AssertionFailedException(ex); + } + + /** + * Create (and caller should subsequently throw) an AssertionFailedException. + * + *

+ * Typical use is as follows: + * + * 

+     * if (something == null) {
+     *     throw AssertionFailedException.shouldNotHappen("Something cannot be null");
+     * }
+     *
+ * + * @param assertion + * message + * @return the exception. exception should be thrown by the caller to satisfy compiler checks for data-flow, etc + * @throws AssertionFailedException + * if exception occurs + */ + public static AssertionFailedException shouldNotHappen(String assertion) throws AssertionFailedException { + return new AssertionFailedException(assertion); + } + + /** + * Creates an AssertionFailedException for the given exception that should + * never have been thrown. + * + * @param ex + * the exception that should never have been thrown. + */ + public AssertionFailedException(Exception ex) { + super(Messages.getString("AssertionFailedException.0") + ex.toString() + Messages.getString("AssertionFailedException.1"), ex); + } + + /** + * Creates an AssertionFailedException for the reason given. + * + * @param assertion + * a description of the assertion that failed + */ + public AssertionFailedException(String assertion) { + super(Messages.getString("AssertionFailedException.2", new Object[] { assertion })); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/CJCommunicationsException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/CJCommunicationsException.java new file mode 100644 index 0000000..9df4e1f --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/CJCommunicationsException.java @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.protocol.PacketReceivedTimeHolder; +import com.mysql.cj.protocol.PacketSentTimeHolder; +import com.mysql.cj.protocol.ServerSession; + +public class CJCommunicationsException extends CJException { + + private static final long serialVersionUID = 344035358493554245L; + + public CJCommunicationsException() { + super(); + } + + public CJCommunicationsException(String message) { + super(message); + } + + public CJCommunicationsException(String message, Throwable cause) { + super(message, cause); + } + + public CJCommunicationsException(Throwable cause) { + super(cause); + } + + protected CJCommunicationsException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + } + + public void init(PropertySet propertySet, ServerSession serverSession, PacketSentTimeHolder packetSentTimeHolder, + PacketReceivedTimeHolder packetReceivedTimeHolder) { + this.exceptionMessage = ExceptionFactory.createLinkFailureMessageBasedOnHeuristics(propertySet, serverSession, packetSentTimeHolder, + packetReceivedTimeHolder, getCause()); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/CJConnectionFeatureNotAvailableException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/CJConnectionFeatureNotAvailableException.java new file mode 100644 index 0000000..eb33373 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/CJConnectionFeatureNotAvailableException.java @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +import com.mysql.cj.Messages; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.protocol.PacketSentTimeHolder; +import com.mysql.cj.protocol.ServerSession; + +public class CJConnectionFeatureNotAvailableException extends CJCommunicationsException { + + private static final long serialVersionUID = -4129847384681995107L; + + public CJConnectionFeatureNotAvailableException() { + super(); + } + + public CJConnectionFeatureNotAvailableException(PropertySet propertySet, ServerSession serverSession, PacketSentTimeHolder packetSentTimeHolder, + Exception underlyingException) { + super(underlyingException); + init(propertySet, serverSession, packetSentTimeHolder, null); + } + + @Override + public String getMessage() { + return Messages.getString("ConnectionFeatureNotAvailableException.0"); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/CJException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/CJException.java new file mode 100644 index 0000000..8f7e0f4 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/CJException.java @@ -0,0 +1,103 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +/** + * The base unchecked exception thrown internally in connector. + */ +public class CJException extends RuntimeException { + + private static final long serialVersionUID = -8618536991444733607L; + + /** + * We can't override the {@link Throwable#detailMessage} directly because it has a private accessibility, + * thus for that need we use this protected variable and override {@link #getMessage()} + */ + protected String exceptionMessage; + + private String SQLState = "S1000"; // GENERAL_ERROR by default + + private int vendorCode = 0; + + private boolean isTransient = false; + + public CJException() { + super(); + } + + public CJException(String message) { + super(message); + } + + public CJException(Throwable cause) { + super(cause); + } + + public CJException(String message, Throwable cause) { + super(message, cause); + } + + protected CJException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + } + + public String getSQLState() { + return this.SQLState; + } + + public void setSQLState(String sQLState) { + this.SQLState = sQLState; + } + + public int getVendorCode() { + return this.vendorCode; + } + + public void setVendorCode(int vendorCode) { + this.vendorCode = vendorCode; + } + + public boolean isTransient() { + return this.isTransient; + } + + public void setTransient(boolean isTransient) { + this.isTransient = isTransient; + } + + @Override + public String getMessage() { + return this.exceptionMessage != null ? this.exceptionMessage : super.getMessage(); + } + + public void appendMessage(String messageToAppend) { + this.exceptionMessage = getMessage() + messageToAppend; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/CJOperationNotSupportedException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/CJOperationNotSupportedException.java new file mode 100644 index 0000000..49cd927 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/CJOperationNotSupportedException.java @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2016, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +public class CJOperationNotSupportedException extends CJException { + + private static final long serialVersionUID = 2619184100062994443L; + + public CJOperationNotSupportedException() { + super(); + } + + public CJOperationNotSupportedException(String message) { + super(message); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/CJPacketTooBigException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/CJPacketTooBigException.java new file mode 100644 index 0000000..18b8cad --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/CJPacketTooBigException.java @@ -0,0 +1,69 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +import com.mysql.cj.Messages; + +/** + * Thrown when a packet that is too big for the server is created. + */ +public class CJPacketTooBigException extends CJException { + + private static final long serialVersionUID = 7186090399276725363L; + + public CJPacketTooBigException() { + super(); + } + + public CJPacketTooBigException(String message) { + super(message); + } + + public CJPacketTooBigException(Throwable cause) { + super(cause); + } + + public CJPacketTooBigException(String message, Throwable cause) { + super(message, cause); + } + + /** + * Creates a new CJPacketTooBigException object. + * + * @param packetSize + * the size of the packet that was going to be sent + * @param maximumPacketSize + * the maximum size the server will accept + */ + public CJPacketTooBigException(long packetSize, long maximumPacketSize) { + super(Messages.getString("PacketTooBigException.0", new Object[] { packetSize, maximumPacketSize })); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/CJTimeoutException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/CJTimeoutException.java new file mode 100644 index 0000000..36a059c --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/CJTimeoutException.java @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +import com.mysql.cj.Messages; + +public class CJTimeoutException extends CJException { + + private static final long serialVersionUID = -7440108828056331100L; + + public CJTimeoutException() { + super(Messages.getString("MySQLTimeoutException.0")); + } + + public CJTimeoutException(String message) { + super(message); + } + + public CJTimeoutException(Throwable cause) { + super(cause); + } + + public CJTimeoutException(String message, Throwable cause) { + super(message, cause); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/ClosedOnExpiredPasswordException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/ClosedOnExpiredPasswordException.java new file mode 100644 index 0000000..4203cfd --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/ClosedOnExpiredPasswordException.java @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +/** + * Equivalent to SQLSTATE ER_MUST_CHANGE_PASSWORD_LOGIN = 1862 + * "Your password has expired. To log in you must change it using a client that supports expired passwords." + * + * Server closes connection when this failure happens. + */ +public class ClosedOnExpiredPasswordException extends CJException { + + private static final long serialVersionUID = -3807215681364413250L; + + public ClosedOnExpiredPasswordException() { + super(); + setVendorCode(MysqlErrorNumbers.ER_MUST_CHANGE_PASSWORD_LOGIN); + } + + public ClosedOnExpiredPasswordException(String message) { + super(message); + setVendorCode(MysqlErrorNumbers.ER_MUST_CHANGE_PASSWORD_LOGIN); + } + + public ClosedOnExpiredPasswordException(String message, Throwable cause) { + super(message, cause); + setVendorCode(MysqlErrorNumbers.ER_MUST_CHANGE_PASSWORD_LOGIN); + } + + public ClosedOnExpiredPasswordException(Throwable cause) { + super(cause); + setVendorCode(MysqlErrorNumbers.ER_MUST_CHANGE_PASSWORD_LOGIN); + } + + protected ClosedOnExpiredPasswordException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + setVendorCode(MysqlErrorNumbers.ER_MUST_CHANGE_PASSWORD_LOGIN); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/ConnectionIsClosedException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/ConnectionIsClosedException.java new file mode 100644 index 0000000..e1fd64c --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/ConnectionIsClosedException.java @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +/** + * Operation attempted on already closed Connection + */ +public class ConnectionIsClosedException extends CJException { + + private static final long serialVersionUID = -8001652264426656450L; + + public ConnectionIsClosedException() { + super(); + setSQLState("08003"); + } + + public ConnectionIsClosedException(String message) { + super(message); + setSQLState("08003"); + } + + public ConnectionIsClosedException(String message, Throwable cause) { + super(message, cause); + setSQLState("08003"); + } + + public ConnectionIsClosedException(Throwable cause) { + super(cause); + setSQLState("08003"); + } + + protected ConnectionIsClosedException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + setSQLState("08003"); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/DataConversionException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/DataConversionException.java new file mode 100644 index 0000000..bafd1c7 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/DataConversionException.java @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +/** + * Indicates that data could not be converted according to the given request. + */ +public class DataConversionException extends DataReadException { + private static final long serialVersionUID = -863576663404236982L; + + public DataConversionException(String msg) { + super(msg); + setSQLState("22018"); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/DataReadException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/DataReadException.java new file mode 100644 index 0000000..f828013 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/DataReadException.java @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +/** + * Indicates that data could not be read according to the given request. + */ +public class DataReadException extends CJException { + private static final long serialVersionUID = 1684265521187171525L; + + public DataReadException(Exception cause) { + super(cause); + setSQLState("S1009"); + } + + public DataReadException(String msg) { + super(msg); + setSQLState("S1009"); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/DataTruncationException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/DataTruncationException.java new file mode 100644 index 0000000..42e0025 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/DataTruncationException.java @@ -0,0 +1,112 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +public class DataTruncationException extends CJException { + + private static final long serialVersionUID = -5209088385943506720L; + + private int index; + private boolean parameter; + private boolean read; + private int dataSize; + private int transferSize; + + public DataTruncationException() { + super(); + } + + public DataTruncationException(String message) { + super(message); + } + + public DataTruncationException(String message, Throwable cause) { + super(message, cause); + } + + public DataTruncationException(Throwable cause) { + super(cause); + } + + protected DataTruncationException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + } + + public DataTruncationException(String message, int index, boolean parameter, boolean read, int dataSize, int transferSize, int vendorErrorCode) { + super(message); + this.setIndex(index); + this.setParameter(parameter); + this.setRead(read); + this.setDataSize(dataSize); + this.setTransferSize(transferSize); + setVendorCode(vendorErrorCode); + } + + public int getIndex() { + return this.index; + } + + public void setIndex(int index) { + this.index = index; + } + + public boolean isParameter() { + return this.parameter; + } + + public void setParameter(boolean parameter) { + this.parameter = parameter; + } + + public boolean isRead() { + return this.read; + } + + public void setRead(boolean read) { + this.read = read; + } + + public int getDataSize() { + return this.dataSize; + } + + public void setDataSize(int dataSize) { + this.dataSize = dataSize; + } + + public int getTransferSize() { + return this.transferSize; + } + + public void setTransferSize(int transferSize) { + this.transferSize = transferSize; + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/DeadlockTimeoutRollbackMarker.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/DeadlockTimeoutRollbackMarker.java new file mode 100644 index 0000000..010cf2a --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/DeadlockTimeoutRollbackMarker.java @@ -0,0 +1,37 @@ +/* + * Copyright (c) 2008, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +/** + * Marker interface for exceptions that are caused by deadlock/wait timeout + */ +public interface DeadlockTimeoutRollbackMarker { + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/ExceptionFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/ExceptionFactory.java new file mode 100644 index 0000000..8b8ff26 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/ExceptionFactory.java @@ -0,0 +1,307 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +import java.net.BindException; + +import com.mysql.cj.Messages; +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.protocol.PacketReceivedTimeHolder; +import com.mysql.cj.protocol.PacketSentTimeHolder; +import com.mysql.cj.protocol.ServerSession; +import com.mysql.cj.util.Util; + +public class ExceptionFactory { + + private static final long DEFAULT_WAIT_TIMEOUT_SECONDS = 28800; + + private static final int DUE_TO_TIMEOUT_FALSE = 0; + + private static final int DUE_TO_TIMEOUT_MAYBE = 2; + + private static final int DUE_TO_TIMEOUT_TRUE = 1; + + public static CJException createException(String message) { + return createException(CJException.class, message); + } + + @SuppressWarnings("unchecked") + public static T createException(Class clazz, String message) { + + T sqlEx; + try { + sqlEx = clazz.getConstructor(String.class).newInstance(message); + } catch (Throwable e) { + sqlEx = (T) new CJException(message); + } + return sqlEx; + } + + public static CJException createException(String message, ExceptionInterceptor interceptor) { + return createException(CJException.class, message, interceptor); + } + + /** + * + * @param clazz + * exception class + * @param message + * message + * @param interceptor + * exception interceptor + * @param + * {@link CJException} + * @return {@link CJException} instance + */ + public static T createException(Class clazz, String message, ExceptionInterceptor interceptor) { + T sqlEx = createException(clazz, message); + + // TODO: Decide whether we need to intercept exceptions at this level + //if (interceptor != null) { + // @SuppressWarnings("unchecked") + // T interceptedEx = (T) interceptor.interceptException(sqlEx, null); + // if (interceptedEx != null) { + // return interceptedEx; + // } + //} + + return sqlEx; + } + + public static CJException createException(String message, Throwable cause) { + return createException(CJException.class, message, cause); + } + + public static T createException(Class clazz, String message, Throwable cause) { + + T sqlEx = createException(clazz, message); + + if (cause != null) { + try { + sqlEx.initCause(cause); + } catch (Throwable t) { + // we're not going to muck with that here, since it's an error condition anyway! + } + + if (cause instanceof CJException) { + sqlEx.setSQLState(((CJException) cause).getSQLState()); + sqlEx.setVendorCode(((CJException) cause).getVendorCode()); + sqlEx.setTransient(((CJException) cause).isTransient()); + } + } + return sqlEx; + } + + public static CJException createException(String message, Throwable cause, ExceptionInterceptor interceptor) { + return createException(CJException.class, message, cause, interceptor); + } + + public static CJException createException(String message, String sqlState, int vendorErrorCode, boolean isTransient, Throwable cause, + ExceptionInterceptor interceptor) { + CJException ex = createException(CJException.class, message, cause, interceptor); + ex.setSQLState(sqlState); + ex.setVendorCode(vendorErrorCode); + ex.setTransient(isTransient); + return ex; + } + + /** + * + * @param clazz + * exception class + * @param message + * message + * @param cause + * exception caused this one + * @param interceptor + * exception interceptor + * @param + * {@link CJException} + * @return {@link CJException} instance + */ + public static T createException(Class clazz, String message, Throwable cause, ExceptionInterceptor interceptor) { + T sqlEx = createException(clazz, message, cause); + + // TODO: Decide whether we need to intercept exceptions at this level + //if (interceptor != null) { + // @SuppressWarnings("unchecked") + // T interceptedEx = (T) interceptor.interceptException(sqlEx, null); + // if (interceptedEx != null) { + // return interceptedEx; + // } + //} + + return sqlEx; + } + + public static CJCommunicationsException createCommunicationsException(PropertySet propertySet, ServerSession serverSession, + PacketSentTimeHolder packetSentTimeHolder, PacketReceivedTimeHolder packetReceivedTimeHolder, Throwable cause, ExceptionInterceptor interceptor) { + CJCommunicationsException sqlEx = createException(CJCommunicationsException.class, null, cause, interceptor); + sqlEx.init(propertySet, serverSession, packetSentTimeHolder, packetReceivedTimeHolder); + + // TODO: Decide whether we need to intercept exceptions at this level + //if (interceptor != null) { + // @SuppressWarnings("unchecked") + // T interceptedEx = (T) interceptor.interceptException(sqlEx, null); + // if (interceptedEx != null) { + // return interceptedEx; + // } + //} + + return sqlEx; + } + + /** + * Creates a communications link failure message to be used in CommunicationsException + * that (hopefully) has some better information and suggestions based on heuristics. + * + * @param propertySet + * property set + * @param serverSession + * server session + * @param packetSentTimeHolder + * packetSentTimeHolder + * @param packetReceivedTimeHolder + * packetReceivedTimeHolder + * @param underlyingException + * underlyingException + * @return message + */ + public static String createLinkFailureMessageBasedOnHeuristics(PropertySet propertySet, ServerSession serverSession, + PacketSentTimeHolder packetSentTimeHolder, PacketReceivedTimeHolder packetReceivedTimeHolder, Throwable underlyingException) { + long serverTimeoutSeconds = 0; + boolean isInteractiveClient = false; + + long lastPacketReceivedTimeMs = packetReceivedTimeHolder == null ? 0L : packetReceivedTimeHolder.getLastPacketReceivedTime(); + long lastPacketSentTimeMs = packetSentTimeHolder.getLastPacketSentTime(); + if (lastPacketSentTimeMs > lastPacketReceivedTimeMs) { + lastPacketSentTimeMs = packetSentTimeHolder.getPreviousPacketSentTime(); + } + + if (propertySet != null) { + isInteractiveClient = propertySet.getBooleanProperty(PropertyKey.interactiveClient).getValue(); + + String serverTimeoutSecondsStr = null; + + if (serverSession != null) { + serverTimeoutSecondsStr = isInteractiveClient ? serverSession.getServerVariable("interactive_timeout") + : serverSession.getServerVariable("wait_timeout"); + } + + if (serverTimeoutSecondsStr != null) { + try { + serverTimeoutSeconds = Long.parseLong(serverTimeoutSecondsStr); + } catch (NumberFormatException nfe) { + serverTimeoutSeconds = 0; + } + } + } + + StringBuilder exceptionMessageBuf = new StringBuilder(); + + long nowMs = System.currentTimeMillis(); + + if (lastPacketSentTimeMs == 0) { + lastPacketSentTimeMs = nowMs; + } + + long timeSinceLastPacketSentMs = (nowMs - lastPacketSentTimeMs); + long timeSinceLastPacketSeconds = timeSinceLastPacketSentMs / 1000; + + long timeSinceLastPacketReceivedMs = (nowMs - lastPacketReceivedTimeMs); + + int dueToTimeout = DUE_TO_TIMEOUT_FALSE; + + StringBuilder timeoutMessageBuf = null; + + if (serverTimeoutSeconds != 0) { + if (timeSinceLastPacketSeconds > serverTimeoutSeconds) { + dueToTimeout = DUE_TO_TIMEOUT_TRUE; + + timeoutMessageBuf = new StringBuilder(); + timeoutMessageBuf.append(Messages.getString("CommunicationsException.2")); + timeoutMessageBuf.append(Messages.getString(isInteractiveClient ? "CommunicationsException.4" : "CommunicationsException.3")); + } + + } else if (timeSinceLastPacketSeconds > DEFAULT_WAIT_TIMEOUT_SECONDS) { + dueToTimeout = DUE_TO_TIMEOUT_MAYBE; + + timeoutMessageBuf = new StringBuilder(); + timeoutMessageBuf.append(Messages.getString("CommunicationsException.5")); + timeoutMessageBuf.append(Messages.getString("CommunicationsException.6")); + timeoutMessageBuf.append(Messages.getString("CommunicationsException.7")); + timeoutMessageBuf.append(Messages.getString("CommunicationsException.8")); + } + + if (dueToTimeout == DUE_TO_TIMEOUT_TRUE || dueToTimeout == DUE_TO_TIMEOUT_MAYBE) { + + exceptionMessageBuf.append(lastPacketReceivedTimeMs != 0 + ? Messages.getString("CommunicationsException.ServerPacketTimingInfo", + new Object[] { Long.valueOf(timeSinceLastPacketReceivedMs), Long.valueOf(timeSinceLastPacketSentMs) }) + : Messages.getString("CommunicationsException.ServerPacketTimingInfoNoRecv", new Object[] { Long.valueOf(timeSinceLastPacketSentMs) })); + + if (timeoutMessageBuf != null) { + exceptionMessageBuf.append(timeoutMessageBuf); + } + + exceptionMessageBuf.append(Messages.getString("CommunicationsException.11")); + exceptionMessageBuf.append(Messages.getString("CommunicationsException.12")); + exceptionMessageBuf.append(Messages.getString("CommunicationsException.13")); + + } else { + // + // Attempt to determine the reason for the underlying exception (we can only make a best-guess here) + // + if (underlyingException instanceof BindException) { + String localSocketAddress = propertySet.getStringProperty(PropertyKey.localSocketAddress).getValue(); + exceptionMessageBuf.append(localSocketAddress != null && !Util.interfaceExists(localSocketAddress) + ? Messages.getString("CommunicationsException.LocalSocketAddressNotAvailable") + : Messages.getString("CommunicationsException.TooManyClientConnections")); + } + } + + if (exceptionMessageBuf.length() == 0) { + // We haven't figured out a good reason, so copy it. + exceptionMessageBuf.append(Messages.getString("CommunicationsException.20")); + + if (propertySet.getBooleanProperty(PropertyKey.maintainTimeStats).getValue() && !propertySet.getBooleanProperty(PropertyKey.paranoid).getValue()) { + exceptionMessageBuf.append("\n\n"); + exceptionMessageBuf.append(lastPacketReceivedTimeMs != 0 + ? Messages.getString("CommunicationsException.ServerPacketTimingInfo", + new Object[] { Long.valueOf(timeSinceLastPacketReceivedMs), Long.valueOf(timeSinceLastPacketSentMs) }) + : Messages.getString("CommunicationsException.ServerPacketTimingInfoNoRecv", new Object[] { Long.valueOf(timeSinceLastPacketSentMs) })); + } + } + + return exceptionMessageBuf.toString(); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/ExceptionInterceptor.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/ExceptionInterceptor.java new file mode 100644 index 0000000..5038bd6 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/ExceptionInterceptor.java @@ -0,0 +1,65 @@ +/* + * Copyright (c) 2008, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +import java.util.Properties; + +import com.mysql.cj.log.Log; + +public interface ExceptionInterceptor { + + /** + * Called once per connection that wants to use the extension + * + * The properties are the same ones passed in in the URL or arguments to + * Driver.connect() or DriverManager.getConnection(). + * + * @param props + * configuration values as passed to the connection. Note that + * in order to support javax.sql.DataSources, configuration properties specific + * to an interceptor must be passed via setURL() on the + * DataSource. Extension properties are not exposed via + * accessor/mutator methods on DataSources. + * @param log + * logger instance + * @return {@link ExceptionInterceptor} + */ + + ExceptionInterceptor init(Properties props, Log log); + + /** + * Called by the driver when this extension should release any resources + * it is holding and cleanup internally before the connection is + * closed. + */ + void destroy(); + + Exception interceptException(Exception sqlEx); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/ExceptionInterceptorChain.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/ExceptionInterceptorChain.java new file mode 100644 index 0000000..ad9848e --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/ExceptionInterceptorChain.java @@ -0,0 +1,90 @@ +/* + * Copyright (c) 2017, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +import java.util.Iterator; +import java.util.List; +import java.util.Properties; +import java.util.stream.Collectors; + +import com.mysql.cj.log.Log; +import com.mysql.cj.util.Util; + +public class ExceptionInterceptorChain implements ExceptionInterceptor { + List interceptors; + + public ExceptionInterceptorChain(String interceptorClasses, Properties props, Log log) { + this.interceptors = Util. loadClasses(interceptorClasses, "Connection.BadExceptionInterceptor", this).stream() + .map(o -> o.init(props, log)).collect(Collectors.toList()); + } + + public void addRingZero(ExceptionInterceptor interceptor) { + this.interceptors.add(0, interceptor); + } + + public Exception interceptException(Exception sqlEx) { + if (this.interceptors != null) { + Iterator iter = this.interceptors.iterator(); + + while (iter.hasNext()) { + sqlEx = iter.next().interceptException(sqlEx); + } + } + + return sqlEx; + } + + public void destroy() { + if (this.interceptors != null) { + Iterator iter = this.interceptors.iterator(); + + while (iter.hasNext()) { + iter.next().destroy(); + } + } + + } + + public ExceptionInterceptor init(Properties properties, Log log) { + if (this.interceptors != null) { + Iterator iter = this.interceptors.iterator(); + + while (iter.hasNext()) { + iter.next().init(properties, log); + } + } + return this; + } + + public List getInterceptors() { + return this.interceptors; + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/FeatureNotAvailableException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/FeatureNotAvailableException.java new file mode 100644 index 0000000..58bab23 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/FeatureNotAvailableException.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +public class FeatureNotAvailableException extends CJException { + + private static final long serialVersionUID = -6649508222074639690L; + + public FeatureNotAvailableException() { + super(); + } + + public FeatureNotAvailableException(String message) { + super(message); + } + + public FeatureNotAvailableException(String message, Throwable cause) { + super(message, cause); + } + + public FeatureNotAvailableException(Throwable cause) { + super(cause); + } + + public FeatureNotAvailableException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/InvalidConnectionAttributeException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/InvalidConnectionAttributeException.java new file mode 100644 index 0000000..0db81f8 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/InvalidConnectionAttributeException.java @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +public class InvalidConnectionAttributeException extends CJException { + + private static final long serialVersionUID = -4814924499233623016L; + + public InvalidConnectionAttributeException() { + super(); + setSQLState("01S00"); + } + + public InvalidConnectionAttributeException(String message) { + super(message); + setSQLState("01S00"); + } + + public InvalidConnectionAttributeException(String message, Throwable cause) { + super(message, cause); + setSQLState("01S00"); + } + + public InvalidConnectionAttributeException(Throwable cause) { + super(cause); + setSQLState("01S00"); + } + + public InvalidConnectionAttributeException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + setSQLState("01S00"); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/MysqlErrorNumbers.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/MysqlErrorNumbers.java new file mode 100644 index 0000000..e3760ad --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/MysqlErrorNumbers.java @@ -0,0 +1,1521 @@ +/* + * Copyright (c) 2002, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +import java.util.HashMap; +import java.util.Map; + +import com.mysql.cj.Messages; + +/** + * Constants representing MySQL error numbers returned by the server in error messages. + */ +public final class MysqlErrorNumbers { + + public final static int ER_ERROR_MESSAGES = 298; + public final static int ER_HASHCHK = 1000; //SQLSTATE: HY000 Message: hashchk + public final static int ER_NISAMCHK = 1001; //SQLSTATE: HY000 Message: isamchk + public final static int ER_NO = 1002; //SQLSTATE: HY000 Message: NO; Used in the construction of other messages. + public final static int ER_YES = 1003; //SQLSTATE: HY000 Message: YES + public final static int ER_CANT_CREATE_FILE = 1004; //SQLSTATE: HY000 Message: Can't create file '%s' (errno: %d - %s) + public final static int ER_CANT_CREATE_TABLE = 1005; //SQLSTATE: HY000 Message: Can't create table '%s' (errno: %d) + public final static int ER_CANT_CREATE_DB = 1006; //SQLSTATE: HY000 Message: Can't create database '%s' (errno: %d) + public final static int ER_DB_CREATE_EXISTS = 1007; //SQLSTATE: HY000 Message: Can't create database '%s'; database exists... + public final static int ER_DB_DROP_EXISTS = 1008; //SQLSTATE: HY000 Message: Can't drop database '%s'; database doesn't exist + public final static int ER_DB_DROP_DELETE = 1009; //SQLSTATE: HY000 Message: Error dropping database (can't delete '%s', errno: %d) + public final static int ER_DB_DROP_RMDIR = 1010; //SQLSTATE: HY000 Message: Error dropping database (can't rmdir '%s', errno: %d) + public final static int ER_CANT_DELETE_FILE = 1011; //SQLSTATE: HY000 Message: Error on delete of '%s' (errno: %d - %s) + public final static int ER_CANT_FIND_SYSTEM_REC = 1012; //SQLSTATE: HY000 Message: Can't read record in system table + public final static int ER_CANT_GET_STAT = 1013; //SQLSTATE: HY000 Message: Can't get status of '%s' (errno: %d - %s) + public final static int ER_CANT_GET_WD = 1014; //SQLSTATE: HY000 Message: Can't get working directory (errno: %d - %s) + public final static int ER_CANT_LOCK = 1015; //SQLSTATE: HY000 Message: Can't lock file (errno: %d - %s) + public final static int ER_CANT_OPEN_FILE = 1016; //SQLSTATE: HY000 Message: Can't open file: '%s' (errno: %d - %s) + public final static int ER_FILE_NOT_FOUND = 1017; //SQLSTATE: HY000 Message: Can't find file: '%s' (errno: %d - %s) + public final static int ER_CANT_READ_DIR = 1018; //SQLSTATE: HY000 Message: Can't read dir of '%s' (errno: %d - %s) + public final static int ER_CANT_SET_WD = 1019; //SQLSTATE: HY000 Message: Can't change dir to '%s' (errno: %d - %s) + public final static int ER_CHECKREAD = 1020; //SQLSTATE: HY000 Message: Record has changed since last read in table '%s' + public final static int ER_DISK_FULL = 1021; //SQLSTATE: HY000 Message: Disk full (%s); waiting for someone to free some space... (errno: %d - %s) + public final static int ER_DUP_KEY = 1022; //SQLSTATE: 23000 Message: Can't write; duplicate key in table '%s' + public final static int ER_ERROR_ON_CLOSE = 1023; //SQLSTATE: HY000 Message: Error on close of '%s' (errno: %d - %s) + public final static int ER_ERROR_ON_READ = 1024; //SQLSTATE: HY000 Message: Error reading file '%s' (errno: %d - %s) + public final static int ER_ERROR_ON_RENAME = 1025; //SQLSTATE: HY000 Message: Error on rename of '%s' to '%s' (errno: %d - %s) + public final static int ER_ERROR_ON_WRITE = 1026; //SQLSTATE: HY000 Message: Error writing file '%s' (errno: %d - %s) + public final static int ER_FILE_USED = 1027; //SQLSTATE: HY000 Message: '%s' is locked against change + public final static int ER_FILSORT_ABORT = 1028; //SQLSTATE: HY000 Message: Sort aborted + public final static int ER_FORM_NOT_FOUND = 1029; //SQLSTATE: HY000 Message: View '%s' doesn't exist for '%s' + public final static int ER_GET_ERRNO = 1030; //SQLSTATE: HY000 Message: Got error %d from storage engine... + public final static int ER_ILLEGAL_HA = 1031; //SQLSTATE: HY000 Message: Table storage engine for '%s' doesn't have this option + public final static int ER_KEY_NOT_FOUND = 1032; //SQLSTATE: HY000 Message: Can't find record in '%s' + public final static int ER_NOT_FORM_FILE = 1033; //SQLSTATE: HY000 Message: Incorrect information in file: '%s' + public final static int ER_NOT_KEYFILE = 1034; //SQLSTATE: HY000 Message: Incorrect key file for table '%s'; try to repair it + public final static int ER_OLD_KEYFILE = 1035; //SQLSTATE: HY000 Message: Old key file for table '%s'; repair it! + public final static int ER_OPEN_AS_READONLY = 1036; //SQLSTATE: HY000 Message: Table '%s' is read only + public final static int ER_OUTOFMEMORY = 1037; //SQLSTATE: HY001 Message: Out of memory; restart server and try again (needed %d bytes) + public final static int ER_OUT_OF_SORTMEMORY = 1038; //SQLSTATE: HY001 Message: Out of sort memory, consider increasing server sort buffer size + public final static int ER_UNEXPECTED_EOF = 1039; //SQLSTATE: HY000 Message: Unexpected EOF found when reading file '%s' (errno: %d - %s) + public final static int ER_CON_COUNT_ERROR = 1040; //SQLSTATE: 08004 Message: Too many connections + public final static int ER_OUT_OF_RESOURCES = 1041; //SQLSTATE: HY000 Message: Out of memory; check if mysqld or some other process uses all available memory; if not, you may have to use 'ulimit' to allow mysqld to use more memory or you can add more swap space + public final static int ER_BAD_HOST_ERROR = 1042; //SQLSTATE: 08S01 Message: Can't get hostname for your address + public final static int ER_HANDSHAKE_ERROR = 1043; //SQLSTATE: 08S01 Message: Bad handshake + public final static int ER_DBACCESS_DENIED_ERROR = 1044; //SQLSTATE: 42000 Message: Access denied for user '%s'@'%s' to database '%s' + public final static int ER_ACCESS_DENIED_ERROR = 1045; //SQLSTATE: 28000 Message: Access denied for user '%s'@'%s' (using password: %s) + public final static int ER_NO_DB_ERROR = 1046; //SQLSTATE: 3D000 Message: No database selected + public final static int ER_UNKNOWN_COM_ERROR = 1047; //SQLSTATE: 08S01 Message: Unknown command + public final static int ER_BAD_NULL_ERROR = 1048; //SQLSTATE: 23000 Message: Column '%s' cannot be null + public final static int ER_BAD_DB_ERROR = 1049; //SQLSTATE: 42000 Message: Unknown database '%s' + public final static int ER_TABLE_EXISTS_ERROR = 1050; //SQLSTATE: 42S01 Message: Table '%s' already exists + public final static int ER_BAD_TABLE_ERROR = 1051; //SQLSTATE: 42S02 Message: Unknown table '%s' + public final static int ER_NON_UNIQ_ERROR = 1052; //SQLSTATE: 23000 Message: Column '%s' in %s is ambiguous + public final static int ER_SERVER_SHUTDOWN = 1053; //SQLSTATE: 08S01 Message: Server shutdown in progress + public final static int ER_BAD_FIELD_ERROR = 1054; //SQLSTATE: 42S22 Message: Unknown column '%s' in '%s' + public final static int ER_WRONG_FIELD_WITH_GROUP = 1055; //SQLSTATE: 42000 Message: '%s' isn't in GROUP BY + public final static int ER_WRONG_GROUP_FIELD = 1056; //SQLSTATE: 42000 Message: Can't group on '%s' + public final static int ER_WRONG_SUM_SELECT = 1057; //SQLSTATE: 42000 Message: Statement has sum functions and columns in same statement + public final static int ER_WRONG_VALUE_COUNT = 1058; //SQLSTATE: 21S01 Message: Column count doesn't match value count + public final static int ER_TOO_LONG_IDENT = 1059; //SQLSTATE: 42000 Message: Identifier name '%s' is too long + public final static int ER_DUP_FIELDNAME = 1060; //SQLSTATE: 42S21 Message: Duplicate column name '%s' + public final static int ER_DUP_KEYNAME = 1061; //SQLSTATE: 42000 Message: Duplicate key name '%s' + public final static int ER_DUP_ENTRY = 1062; //SQLSTATE: 23000 Message: Duplicate entry '%s' for key %d + public final static int ER_WRONG_FIELD_SPEC = 1063; //SQLSTATE: 42000 Message: Incorrect column specifier for column '%s' + public final static int ER_PARSE_ERROR = 1064; //SQLSTATE: 42000 Message: %s near '%s' at line %d + public final static int ER_EMPTY_QUERY = 1065; //SQLSTATE: 42000 Message: Query was empty + public final static int ER_NONUNIQ_TABLE = 1066; //SQLSTATE: 42000 Message: Not unique table/alias: '%s' + public final static int ER_INVALID_DEFAULT = 1067; //SQLSTATE: 42000 Message: Invalid default value for '%s' + public final static int ER_MULTIPLE_PRI_KEY = 1068; //SQLSTATE: 42000 Message: Multiple primary key defined + public final static int ER_TOO_MANY_KEYS = 1069; //SQLSTATE: 42000 Message: Too many keys specified; max %d keys allowed + public final static int ER_TOO_MANY_KEY_PARTS = 1070; //SQLSTATE: 42000 Message: Too many key parts specified; max %d parts allowed + public final static int ER_TOO_LONG_KEY = 1071; //SQLSTATE: 42000 Message: Specified key was too long; max key length is %d bytes + public final static int ER_KEY_COLUMN_DOES_NOT_EXITS = 1072; //SQLSTATE: 42000 Message: Key column '%s' doesn't exist in table + public final static int ER_BLOB_USED_AS_KEY = 1073; //SQLSTATE: 42000 Message: BLOB column '%s' can't be used in key specification with the used table type + public final static int ER_TOO_BIG_FIELDLENGTH = 1074; //SQLSTATE: 42000 Message: Column length too big for column '%s' (max = %lu); use BLOB or TEXT instead + public final static int ER_WRONG_AUTO_KEY = 1075; //SQLSTATE: 42000 Message: Incorrect table definition; there can be only one auto column and it must be defined as a key + public final static int ER_READY = 1076; //SQLSTATE: HY000 Message: %s: ready for connections. Version: '%s' socket: '%s' port: %d + public final static int ER_NORMAL_SHUTDOWN = 1077; //SQLSTATE: HY000 Message: %s: Normal shutdown + public final static int ER_GOT_SIGNAL = 1078; //SQLSTATE: HY000 Message: %s: Got signal %d. Aborting! + public final static int ER_SHUTDOWN_COMPLETE = 1079; //SQLSTATE: HY000 Message: %s: Shutdown complete + public final static int ER_FORCING_CLOSE = 1080; //SQLSTATE: 08S01 Message: %s: Forcing close of thread %ld user: '%s' + public final static int ER_IPSOCK_ERROR = 1081; //SQLSTATE: 08S01 Message: Can't create IP socket + public final static int ER_NO_SUCH_INDEX = 1082; //SQLSTATE: 42S12 Message: Table '%s' has no index like the one used in CREATE INDEX; recreate the table + public final static int ER_WRONG_FIELD_TERMINATORS = 1083; //SQLSTATE: 42000 Message: Field separator argument is not what is expected; check the manual + public final static int ER_BLOBS_AND_NO_TERMINATED = 1084; //SQLSTATE: 42000 Message: You can't use fixed rowlength with BLOBs; please use 'fields terminated by' + public final static int ER_TEXTFILE_NOT_READABLE = 1085; //SQLSTATE: HY000 Message: The file '%s' must be in the database directory or be readable by all + public final static int ER_FILE_EXISTS_ERROR = 1086; //SQLSTATE: HY000 Message: File '%s' already exists + public final static int ER_LOAD_INFO = 1087; //SQLSTATE: HY000 Message: Records: %ld Deleted: %ld Skipped: %ld Warnings: %ld + public final static int ER_ALTER_INFO = 1088; //SQLSTATE: HY000 Message: Records: %ld Duplicates: %ld + public final static int ER_WRONG_SUB_KEY = 1089; //SQLSTATE: HY000 Message: Incorrect prefix key; the used key part isn't a string, the used length is longer than the key part, or the storage engine doesn't support unique prefix keys + public final static int ER_CANT_REMOVE_ALL_FIELDS = 1090; //SQLSTATE: 42000 Message: You can't delete all columns with ALTER TABLE; use DROP TABLE instead + public final static int ER_CANT_DROP_FIELD_OR_KEY = 1091; //SQLSTATE: 42000 Message: Can't DROP '%s'; check that column/key exists + public final static int ER_INSERT_INFO = 1092; //SQLSTATE: HY000 Message: Records: %ld Duplicates: %ld Warnings: %ld + public final static int ER_UPDATE_TABLE_USED = 1093; //SQLSTATE: HY000 Message: You can't specify target table '%s' for update in FROM clause + public final static int ER_NO_SUCH_THREAD = 1094; //SQLSTATE: HY000 Message: Unknown thread id: %lu + public final static int ER_KILL_DENIED_ERROR = 1095; //SQLSTATE: HY000 Message: You are not owner of thread %lu + public final static int ER_NO_TABLES_USED = 1096; //SQLSTATE: HY000 Message: No tables used + public final static int ER_TOO_BIG_SET = 1097; //SQLSTATE: HY000 Message: Too many strings for column %s and SET + public final static int ER_NO_UNIQUE_LOGFILE = 1098; //SQLSTATE: HY000 Message: Can't generate a unique log-filename %s.(1-999) + public final static int ER_TABLE_NOT_LOCKED_FOR_WRITE = 1099; //SQLSTATE: HY000 Message: Table '%s' was locked with a READ lock and can't be updated + public final static int ER_TABLE_NOT_LOCKED = 1100; //SQLSTATE: HY000 Message: Table '%s' was not locked with LOCK TABLES + public final static int ER_BLOB_CANT_HAVE_DEFAULT = 1101; //SQLSTATE: 42000 Message: BLOB/TEXT column '%s' can't have a default value + public final static int ER_WRONG_DB_NAME = 1102; //SQLSTATE: 42000 Message: Incorrect database name '%s' + public final static int ER_WRONG_TABLE_NAME = 1103; //SQLSTATE: 42000 Message: Incorrect table name '%s' + public final static int ER_TOO_BIG_SELECT = 1104; //SQLSTATE: 42000 Message: The SELECT would examine more than MAX_JOIN_SIZE rows; check your WHERE and use SET SQL_BIG_SELECTS=1 or SET MAX_JOIN_SIZE=# if the SELECT is okay + public final static int ER_UNKNOWN_ERROR = 1105; //SQLSTATE: HY000 Message: Unknown error + public final static int ER_UNKNOWN_PROCEDURE = 1106; //SQLSTATE: 42000 Message: Unknown procedure '%s' + public final static int ER_WRONG_PARAMCOUNT_TO_PROCEDURE = 1107; //SQLSTATE: 42000 Message: Incorrect parameter count to procedure '%s' + public final static int ER_WRONG_PARAMETERS_TO_PROCEDURE = 1108; //SQLSTATE: HY000 Message: Incorrect parameters to procedure '%s' + public final static int ER_UNKNOWN_TABLE = 1109; //SQLSTATE: 42S02 Message: Unknown table '%s' in %s + public final static int ER_FIELD_SPECIFIED_TWICE = 1110; //SQLSTATE: 42000 Message: Column '%s' specified twice + public final static int ER_INVALID_GROUP_FUNC_USE = 1111; //SQLSTATE: HY000 Message: Invalid use of group function + public final static int ER_UNSUPPORTED_EXTENSION = 1112; //SQLSTATE: 42000 Message: Table '%s' uses an extension that doesn't exist in this MySQL version + public final static int ER_TABLE_MUST_HAVE_COLUMNS = 1113; //SQLSTATE: 42000 Message: A table must have at least 1 column + public final static int ER_RECORD_FILE_FULL = 1114; //SQLSTATE: HY000 Message: The table '%s' is full + public final static int ER_UNKNOWN_CHARACTER_SET = 1115; //SQLSTATE: 42000 Message: Unknown character set: '%s' + public final static int ER_TOO_MANY_TABLES = 1116; //SQLSTATE: HY000 Message: Too many tables; MySQL can only use %d tables in a join + public final static int ER_TOO_MANY_FIELDS = 1117; //SQLSTATE: HY000 Message: Too many columns + public final static int ER_TOO_BIG_ROWSIZE = 1118; //SQLSTATE: 42000 Message: Row size too large. The maximum row size for the used table type, not counting BLOBs, is %ld. This includes storage overhead, check the manual. You have to change some columns to TEXT or BLOBs + public final static int ER_STACK_OVERRUN = 1119; //SQLSTATE: HY000 Message: Thread stack overrun: Used: %ld of a %ld stack. Use 'mysqld --thread_stack=#' to specify a bigger stack if needed + public final static int ER_WRONG_OUTER_JOIN = 1120; //SQLSTATE: 42000 Message: Cross dependency found in OUTER JOIN; examine your ON conditions + public final static int ER_NULL_COLUMN_IN_INDEX = 1121; //SQLSTATE: 42000 Message: Table handler doesn't support NULL in given index. Please change column '%s' to be NOT NULL or use another handler + public final static int ER_CANT_FIND_UDF = 1122; //SQLSTATE: HY000 Message: Can't load function '%s' + public final static int ER_CANT_INITIALIZE_UDF = 1123; //SQLSTATE: HY000 Message: Can't initialize function '%s'; %s + public final static int ER_UDF_NO_PATHS = 1124; //SQLSTATE: HY000 Message: No paths allowed for shared library + public final static int ER_UDF_EXISTS = 1125; //SQLSTATE: HY000 Message: Function '%s' already exists + public final static int ER_CANT_OPEN_LIBRARY = 1126; //SQLSTATE: HY000 Message: Can't open shared library '%s' (errno: %d %s) + public final static int ER_CANT_FIND_DL_ENTRY = 1127; //SQLSTATE: HY000 Message: Can't find symbol '%s' in library + public final static int ER_FUNCTION_NOT_DEFINED = 1128; //SQLSTATE: HY000 Message: Function '%s' is not defined + public final static int ER_HOST_IS_BLOCKED = 1129; //SQLSTATE: HY000 Message: Host '%s' is blocked because of many connection errors; unblock with 'mysqladmin flush-hosts' + public final static int ER_HOST_NOT_PRIVILEGED = 1130; //SQLSTATE: HY000 Message: Host '%s' is not allowed to connect to this MySQL server + public final static int ER_PASSWORD_ANONYMOUS_USER = 1131; //SQLSTATE: 42000 Message: You are using MySQL as an anonymous user and anonymous users are not allowed to change passwords + public final static int ER_PASSWORD_NOT_ALLOWED = 1132; //SQLSTATE: 42000 Message: You must have privileges to update tables in the mysql database to be able to change passwords for others + public final static int ER_PASSWORD_NO_MATCH = 1133; //SQLSTATE: 42000 Message: Can't find any matching row in the user table + public final static int ER_UPDATE_INFO = 1134; //SQLSTATE: HY000 Message: Rows matched: %ld Changed: %ld Warnings: %ld + public final static int ER_CANT_CREATE_THREAD = 1135; //SQLSTATE: HY000 Message: Can't create a new thread (errno %d); if you are not out of available memory, you can consult the manual for a possible OS-dependent bug + public final static int ER_WRONG_VALUE_COUNT_ON_ROW = 1136; //SQLSTATE: 21S01 Message: Column count doesn't match value count at row %ld + public final static int ER_CANT_REOPEN_TABLE = 1137; //SQLSTATE: HY000 Message: Can't reopen table: '%s' + public final static int ER_INVALID_USE_OF_NULL = 1138; //SQLSTATE: 22004 Message: Invalid use of NULL value + public final static int ER_REGEXP_ERROR = 1139; //SQLSTATE: 42000 Message: Got error '%s' from regexp + public final static int ER_MIX_OF_GROUP_FUNC_AND_FIELDS = 1140; //SQLSTATE: 42000 Message: Mixing of GROUP columns (MIN(),MAX(),COUNT(),...) with no GROUP columns is illegal if there is no GROUP BY clause + public final static int ER_NONEXISTING_GRANT = 1141; //SQLSTATE: 42000 Message: There is no such grant defined for user '%s' on host '%s' + public final static int ER_TABLEACCESS_DENIED_ERROR = 1142; //SQLSTATE: 42000 Message: %s command denied to user '%s'@'%s' for table '%s' + public final static int ER_COLUMNACCESS_DENIED_ERROR = 1143; //SQLSTATE: 42000 Message: %s command denied to user '%s'@'%s' for column '%s' in table '%s' + public final static int ER_ILLEGAL_GRANT_FOR_TABLE = 1144; //SQLSTATE: 42000 Message: Illegal GRANT/REVOKE command; please consult the manual to see which privileges can be used + public final static int ER_GRANT_WRONG_HOST_OR_USER = 1145; //SQLSTATE: 42000 Message: The host or user argument to GRANT is too long + public final static int ER_NO_SUCH_TABLE = 1146; //SQLSTATE: 42S02 Message: Table '%s.%s' doesn't exist + public final static int ER_NONEXISTING_TABLE_GRANT = 1147; //SQLSTATE: 42000 Message: There is no such grant defined for user '%s' on host '%s' on table '%s' + public final static int ER_NOT_ALLOWED_COMMAND = 1148; //SQLSTATE: 42000 Message: The used command is not allowed with this MySQL version + public final static int ER_SYNTAX_ERROR = 1149; //SQLSTATE: 42000 Message: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use + public final static int ER_DELAYED_CANT_CHANGE_LOCK = 1150; //SQLSTATE: HY000 Message: Delayed insert thread couldn't get requested lock for table %s + public final static int ER_TOO_MANY_DELAYED_THREADS = 1151; //SQLSTATE: HY000 Message: Too many delayed threads in use + public final static int ER_ABORTING_CONNECTION = 1152; //SQLSTATE: 08S01 Message: Aborted connection %ld to db: '%s' user: '%s' (%s) + public final static int ER_NET_PACKET_TOO_LARGE = 1153; //SQLSTATE: 08S01 Message: Got a packet bigger than 'max_allowed_packet' bytes + public final static int ER_NET_READ_ERROR_FROM_PIPE = 1154; //SQLSTATE: 08S01 Message: Got a read error from the connection pipe + public final static int ER_NET_FCNTL_ERROR = 1155; //SQLSTATE: 08S01 Message: Got an error from fcntl() + public final static int ER_NET_PACKETS_OUT_OF_ORDER = 1156; //SQLSTATE: 08S01 Message: Got packets out of order + public final static int ER_NET_UNCOMPRESS_ERROR = 1157; //SQLSTATE: 08S01 Message: Couldn't uncompress communication packet + public final static int ER_NET_READ_ERROR = 1158; //SQLSTATE: 08S01 Message: Got an error reading communication packets + public final static int ER_NET_READ_INTERRUPTED = 1159; //SQLSTATE: 08S01 Message: Got timeout reading communication packets + public final static int ER_NET_ERROR_ON_WRITE = 1160; //SQLSTATE: 08S01 Message: Got an error writing communication packets + public final static int ER_NET_WRITE_INTERRUPTED = 1161; //SQLSTATE: 08S01 Message: Got timeout writing communication packets + public final static int ER_TOO_LONG_STRING = 1162; //SQLSTATE: 42000 Message: Result string is longer than 'max_allowed_packet' bytes + public final static int ER_TABLE_CANT_HANDLE_BLOB = 1163; //SQLSTATE: 42000 Message: The used table type doesn't support BLOB/TEXT columns + public final static int ER_TABLE_CANT_HANDLE_AUTO_INCREMENT = 1164; //SQLSTATE: 42000 Message: The used table type doesn't support AUTO_INCREMENT columns + public final static int ER_DELAYED_INSERT_TABLE_LOCKED = 1165; //SQLSTATE: HY000 Message: INSERT DELAYED can't be used with table '%s' because it is locked with LOCK TABLES + public final static int ER_WRONG_COLUMN_NAME = 1166; //SQLSTATE: 42000 Message: Incorrect column name '%s' + public final static int ER_WRONG_KEY_COLUMN = 1167; //SQLSTATE: 42000 Message: The used storage engine can't index column '%s' + public final static int ER_WRONG_MRG_TABLE = 1168; //SQLSTATE: HY000 Message: Unable to open underlying table which is differently defined or of non-MyISAM type or doesn't exist + public final static int ER_DUP_UNIQUE = 1169; //SQLSTATE: 23000 Message: Can't write, because of unique constraint, to table '%s' + public final static int ER_BLOB_KEY_WITHOUT_LENGTH = 1170; //SQLSTATE: 42000 Message: BLOB/TEXT column '%s' used in key specification without a key length + public final static int ER_PRIMARY_CANT_HAVE_NULL = 1171; //SQLSTATE: 42000 Message: All parts of a PRIMARY KEY must be NOT NULL; if you need NULL in a key, use UNIQUE instead + public final static int ER_TOO_MANY_ROWS = 1172; //SQLSTATE: 42000 Message: Result consisted of more than one row + public final static int ER_REQUIRES_PRIMARY_KEY = 1173; //SQLSTATE: 42000 Message: This table type requires a primary key + public final static int ER_NO_RAID_COMPILED = 1174; //SQLSTATE: HY000 Message: This version of MySQL is not compiled with RAID support + public final static int ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE = 1175; //SQLSTATE: HY000 Message: You are using safe update mode and you tried to update a table without a WHERE that uses a KEY column + public final static int ER_KEY_DOES_NOT_EXITS = 1176; //SQLSTATE: 42000 Message: Key '%s' doesn't exist in table '%s' + public final static int ER_CHECK_NO_SUCH_TABLE = 1177; //SQLSTATE: 42000 Message: Can't open table + public final static int ER_CHECK_NOT_IMPLEMENTED = 1178; //SQLSTATE: 42000 Message: The storage engine for the table doesn't support %s + public final static int ER_CANT_DO_THIS_DURING_AN_TRANSACTION = 1179; //SQLSTATE: 25000 Message: You are not allowed to execute this command in a transaction + public final static int ER_ERROR_DURING_COMMIT = 1180; //SQLSTATE: HY000 Message: Got error %d during COMMIT + public final static int ER_ERROR_DURING_ROLLBACK = 1181; //SQLSTATE: HY000 Message: Got error %d during ROLLBACK + public final static int ER_ERROR_DURING_FLUSH_LOGS = 1182; //SQLSTATE: HY000 Message: Got error %d during FLUSH_LOGS + public final static int ER_ERROR_DURING_CHECKPOINT = 1183; //SQLSTATE: HY000 Message: Got error %d during CHECKPOINT + public final static int ER_NEW_ABORTING_CONNECTION = 1184; //SQLSTATE: 08S01 Message: Aborted connection %ld to db: '%s' user: '%s' host: '%s' (%s) + public final static int ER_DUMP_NOT_IMPLEMENTED = 1185; //SQLSTATE: HY000 Message: The storage engine for the table does not support binary table dump + @Deprecated + public final static int ER_FLUSH_MASTER_BINLOG_CLOSED = 1186; + public final static int ER_FLUSH_SOURCE_BINLOG_CLOSED = 1186; //SQLSTATE: HY000 Message: Binlog closed, cannot RESET SOURCE + public final static int ER_INDEX_REBUILD = 1187; //SQLSTATE: HY000 Message: Failed rebuilding the index of dumped table '%s' + @Deprecated + public final static int ER_MASTER = 1188; + public final static int ER_SOURCE = 1188; //SQLSTATE: HY000 Message: Error from source: '%s' + @Deprecated + public final static int ER_MASTER_NET_READ = 1189; + public final static int ER_SOURCE_NET_READ = 1189; //SQLSTATE: 08S01 Message: Net error reading from source + @Deprecated + public final static int ER_MASTER_NET_WRITE = 1190; + public final static int ER_SOURCE_NET_WRITE = 1190; //SQLSTATE: 08S01 Message: Net error writing to source + public final static int ER_FT_MATCHING_KEY_NOT_FOUND = 1191; //SQLSTATE: HY000 Message: Can't find FULLTEXT index matching the column list + public final static int ER_LOCK_OR_ACTIVE_TRANSACTION = 1192; //SQLSTATE: HY000 Message: Can't execute the given command because you have active locked tables or an active transaction + public final static int ER_UNKNOWN_SYSTEM_VARIABLE = 1193; //SQLSTATE: HY000 Message: Unknown system variable '%s' + public final static int ER_CRASHED_ON_USAGE = 1194; //SQLSTATE: HY000 Message: Table '%s' is marked as crashed and should be repaired + public final static int ER_CRASHED_ON_REPAIR = 1195; //SQLSTATE: HY000 Message: Table '%s' is marked as crashed and last (automatic?) repair failed + public final static int ER_WARNING_NOT_COMPLETE_ROLLBACK = 1196; //SQLSTATE: HY000 Message: Some non-transactional changed tables couldn't be rolled back + public final static int ER_TRANS_CACHE_FULL = 1197; //SQLSTATE: HY000 Message: Multi-statement transaction required more than 'max_binlog_cache_size' bytes of storage; increase this mysqld variable and try again + @Deprecated + public final static int ER_SLAVE_MUST_STOP = 1198; + public final static int ER_REPLICA_MUST_STOP = 1198; //SQLSTATE: HY000 Message: This operation cannot be performed with a running replica; run STOP REPLICA first + @Deprecated + public final static int ER_SLAVE_NOT_RUNNING = 1199; + public final static int ER_REPLICA_NOT_RUNNING = 1199; //SQLSTATE: HY000 Message: This operation requires a running replica; configure replica and do START REPLICA + @Deprecated + public final static int ER_BAD_SLAVE = 1200; + public final static int ER_BAD_REPLICA = 1200; //SQLSTATE: HY000 Message: The server is not configured as replica; fix in config file or with CHANGE SOURCE TO + @Deprecated + public final static int ER_MASTER_INFO = 1201; + public final static int ER_SOURCE_INFO = 1201; //SQLSTATE: HY000 Message: Could not initialize source info structure; more error messages can be found in the MySQL error log + @Deprecated + public final static int ER_SLAVE_THREAD = 1202; + public final static int ER_REPLICA_THREAD = 1202; //SQLSTATE: HY000 Message: Could not create replica thread; check system resources + public final static int ER_TOO_MANY_USER_CONNECTIONS = 1203; //SQLSTATE: 42000 Message: User %s already has more than 'max_user_connections' active connections + public final static int ER_SET_CONSTANTS_ONLY = 1204; //SQLSTATE: HY000 Message: You may only use constant expressions with SET + public final static int ER_LOCK_WAIT_TIMEOUT = 1205; //SQLSTATE: HY000 Message: Lock wait timeout exceeded; try restarting transaction + public final static int ER_LOCK_TABLE_FULL = 1206; //SQLSTATE: HY000 Message: The total number of locks exceeds the lock table size + public final static int ER_READ_ONLY_TRANSACTION = 1207; //SQLSTATE: 25000 Message: Update locks cannot be acquired during a READ UNCOMMITTED transaction + public final static int ER_DROP_DB_WITH_READ_LOCK = 1208; //SQLSTATE: HY000 Message: DROP DATABASE not allowed while thread is holding global read lock + public final static int ER_CREATE_DB_WITH_READ_LOCK = 1209; //SQLSTATE: HY000 Message: CREATE DATABASE not allowed while thread is holding global read lock + public final static int ER_WRONG_ARGUMENTS = 1210; //SQLSTATE: HY000 Message: Incorrect arguments to %s + public final static int ER_NO_PERMISSION_TO_CREATE_USER = 1211; //SQLSTATE: 42000 Message: '%s'@'%s' is not allowed to create new users + public final static int ER_UNION_TABLES_IN_DIFFERENT_DIR = 1212; //SQLSTATE: HY000 Message: Incorrect table definition; all MERGE tables must be in the same database + public final static int ER_LOCK_DEADLOCK = 1213; //SQLSTATE: 40001 Message: Deadlock found when trying to get lock; try restarting transaction + public final static int ER_TABLE_CANT_HANDLE_FT = 1214; //SQLSTATE: HY000 Message: The used table type doesn't support FULLTEXT indexes + public final static int ER_CANNOT_ADD_FOREIGN = 1215; //SQLSTATE: HY000 Message: Cannot add foreign key constraint + public final static int ER_NO_REFERENCED_ROW = 1216; //SQLSTATE: 23000 Message: Cannot add or update a child row: a foreign key constraint fails + public final static int ER_ROW_IS_REFERENCED = 1217; //SQLSTATE: 23000 Message: Cannot delete or update a parent row: a foreign key constraint fails + @Deprecated + public final static int ER_CONNECT_TO_MASTER = 1218; + public final static int ER_CONNECT_TO_SOURCE = 1218; //SQLSTATE: 08S01 Message: Error connecting to source: %s + @Deprecated + public final static int ER_QUERY_ON_MASTER = 1219; + public final static int ER_QUERY_ON_SOURCE = 1219; //SQLSTATE: HY000 Message: Error running query on source: %s + public final static int ER_ERROR_WHEN_EXECUTING_COMMAND = 1220; //SQLSTATE: HY000 Message: Error when executing command %s: %s + public final static int ER_WRONG_USAGE = 1221; //SQLSTATE: HY000 Message: Incorrect usage of %s and %s + public final static int ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT = 1222; //SQLSTATE: 21000 Message: The used SELECT statements have a different number of columns + public final static int ER_CANT_UPDATE_WITH_READLOCK = 1223; //SQLSTATE: HY000 Message: Can't execute the query because you have a conflicting read lock + public final static int ER_MIXING_NOT_ALLOWED = 1224; //SQLSTATE: HY000 Message: Mixing of transactional and non-transactional tables is disabled + public final static int ER_DUP_ARGUMENT = 1225; //SQLSTATE: HY000 Message: Option '%s' used twice in statement + public final static int ER_USER_LIMIT_REACHED = 1226; //SQLSTATE: 42000 Message: User '%s' has exceeded the '%s' resource (current value: %ld) + public final static int ER_SPECIFIC_ACCESS_DENIED_ERROR = 1227; //SQLSTATE: 42000 Message: Access denied; you need (at least one of) the %s privilege(s) for this operation + public final static int ER_LOCAL_VARIABLE = 1228; //SQLSTATE: HY000 Message: Variable '%s' is a SESSION variable and can't be used with SET GLOBAL + public final static int ER_GLOBAL_VARIABLE = 1229; //SQLSTATE: HY000 Message: Variable '%s' is a GLOBAL variable and should be set with SET GLOBAL + public final static int ER_NO_DEFAULT = 1230; //SQLSTATE: 42000 Message: Variable '%s' doesn't have a default value + public final static int ER_WRONG_VALUE_FOR_VAR = 1231; //SQLSTATE: 42000 Message: Variable '%s' can't be set to the value of '%s' + public final static int ER_WRONG_TYPE_FOR_VAR = 1232; //SQLSTATE: 42000 Message: Incorrect argument type to variable '%s' + public final static int ER_VAR_CANT_BE_READ = 1233; //SQLSTATE: HY000 Message: Variable '%s' can only be set, not read + public final static int ER_CANT_USE_OPTION_HERE = 1234; //SQLSTATE: 42000 Message: Incorrect usage/placement of '%s' + public final static int ER_NOT_SUPPORTED_YET = 1235; //SQLSTATE: 42000 Message: This version of MySQL doesn't yet support '%s' + @Deprecated + public final static int ER_MASTER_FATAL_ERROR_READING_BINLOG = 1236; + public final static int ER_SOURCE_FATAL_ERROR_READING_BINLOG = 1236; //SQLSTATE: HY000 Message: Got fatal error %d from source when reading data from binary log: '%s' + @Deprecated + public final static int ER_SLAVE_IGNORED_TABLE = 1237; + public final static int ER_REPLICA_IGNORED_TABLE = 1237; //SQLSTATE: HY000 Message: Replica SQL thread ignored the query because of replicate-*-table rules + public final static int ER_INCORRECT_GLOBAL_LOCAL_VAR = 1238; //SQLSTATE: HY000 Message: Variable '%s' is a %s variable + public final static int ER_WRONG_FK_DEF = 1239; //SQLSTATE: 42000 Message: Incorrect foreign key definition for '%s': %s + public final static int ER_KEY_REF_DO_NOT_MATCH_TABLE_REF = 1240; //SQLSTATE: HY000 Message: Key reference and table reference don't match + public final static int ER_OPERAND_COLUMNS = 1241; //SQLSTATE: 21000 Message: Operand should contain %d column(s) + public final static int ER_SUBQUERY_NO_1_ROW = 1242; //SQLSTATE: 21000 Message: Subquery returns more than 1 row + public final static int ER_UNKNOWN_STMT_HANDLER = 1243; //SQLSTATE: HY000 Message: Unknown prepared statement handler (%.*s) given to %s + public final static int ER_CORRUPT_HELP_DB = 1244; //SQLSTATE: HY000 Message: Help database is corrupt or does not exist + public final static int ER_CYCLIC_REFERENCE = 1245; //SQLSTATE: HY000 Message: Cyclic reference on subqueries + public final static int ER_AUTO_CONVERT = 1246; //SQLSTATE: HY000 Message: Converting column '%s' from %s to %s + public final static int ER_ILLEGAL_REFERENCE = 1247; //SQLSTATE: 42S22 Message: Reference '%s' not supported (%s) + public final static int ER_DERIVED_MUST_HAVE_ALIAS = 1248; //SQLSTATE: 42000 Message: Every derived table must have its own alias + public final static int ER_SELECT_REDUCED = 1249; //SQLSTATE: 01000 Message: Select %u was reduced during optimization + public final static int ER_TABLENAME_NOT_ALLOWED_HERE = 1250; //SQLSTATE: 42000 Message: Table '%s' from one of the SELECTs cannot be used in %s + public final static int ER_NOT_SUPPORTED_AUTH_MODE = 1251; //SQLSTATE: 08004 Message: Client does not support authentication protocol requested by server; consider upgrading MySQL client + public final static int ER_SPATIAL_CANT_HAVE_NULL = 1252; //SQLSTATE: 42000 Message: All parts of a SPATIAL index must be NOT NULL + public final static int ER_COLLATION_CHARSET_MISMATCH = 1253; //SQLSTATE: 42000 Message: COLLATION '%s' is not valid for CHARACTER SET '%s' + @Deprecated + public final static int ER_SLAVE_WAS_RUNNING = 1254; + public final static int ER_REPLICA_WAS_RUNNING = 1254; //SQLSTATE: HY000 Message: Replica is already running + @Deprecated + public final static int ER_SLAVE_WAS_NOT_RUNNING = 1255; + public final static int ER_REPLICA_WAS_NOT_RUNNING = 1255; //SQLSTATE: HY000 Message: Replica already has been stopped + public final static int ER_TOO_BIG_FOR_UNCOMPRESS = 1256; //SQLSTATE: HY000 Message: Uncompressed data size too large; the maximum size is %d (probably, length of uncompressed data was corrupted) + public final static int ER_ZLIB_Z_MEM_ERROR = 1257; //SQLSTATE: HY000 Message: ZLIB: Not enough memory + public final static int ER_ZLIB_Z_BUF_ERROR = 1258; //SQLSTATE: HY000 Message: ZLIB: Not enough room in the output buffer (probably, length of uncompressed data was corrupted) + public final static int ER_ZLIB_Z_DATA_ERROR = 1259; //SQLSTATE: HY000 Message: ZLIB: Input data corrupted + public final static int ER_CUT_VALUE_GROUP_CONCAT = 1260; //SQLSTATE: HY000 Message: Row %u was cut by GROUP_CONCAT() + public final static int ER_WARN_TOO_FEW_RECORDS = 1261; //SQLSTATE: 01000 Message: Row %ld doesn't contain data for all columns + public final static int ER_WARN_TOO_MANY_RECORDS = 1262; //SQLSTATE: 01000 Message: Row %ld was truncated; it contained more data than there were input columns + public final static int ER_WARN_NULL_TO_NOTNULL = 1263; //SQLSTATE: 22004 Message: Column set to default value; NULL supplied to NOT NULL column '%s' at row %ld + public final static int ER_WARN_DATA_OUT_OF_RANGE = 1264; //SQLSTATE: 22003 Message: Out of range value for column '%s' at row %ld + public final static int ER_WARN_DATA_TRUNCATED = 1265; //SQLSTATE: 01000 Message: Data truncated for column '%s' at row %ld + public final static int ER_WARN_USING_OTHER_HANDLER = 1266; //SQLSTATE: HY000 Message: Using storage engine %s for table '%s' + public final static int ER_CANT_AGGREGATE_2COLLATIONS = 1267; //SQLSTATE: HY000 Message: Illegal mix of collations (%s,%s) and (%s,%s) for operation '%s' + public final static int ER_DROP_USER = 1268; //SQLSTATE: HY000 Message: Cannot drop one or more of the requested users + public final static int ER_REVOKE_GRANTS = 1269; //SQLSTATE: HY000 Message: Can't revoke all privileges for one or more of the requested users + public final static int ER_CANT_AGGREGATE_3COLLATIONS = 1270; //SQLSTATE: HY000 Message: Illegal mix of collations (%s,%s), (%s,%s), (%s,%s) for operation '%s' + public final static int ER_CANT_AGGREGATE_NCOLLATIONS = 1271; //SQLSTATE: HY000 Message: Illegal mix of collations for operation '%s' + public final static int ER_VARIABLE_IS_NOT_STRUCT = 1272; //SQLSTATE: HY000 Message: Variable '%s' is not a variable component (can't be used as XXXX.variable_name) + public final static int ER_UNKNOWN_COLLATION = 1273; //SQLSTATE: HY000 Message: Unknown collation: '%s' + @Deprecated + public final static int ER_SLAVE_IGNORED_SSL_PARAMS = 1274; + public final static int ER_REPLICA_IGNORED_SSL_PARAMS = 1274; //SQLSTATE: HY000 Message: SSL parameters in CHANGE SOURCE are ignored because this MySQL replica was compiled without SSL support; they can be used later if MySQL replica with SSL is started + public final static int ER_SERVER_IS_IN_SECURE_AUTH_MODE = 1275; //SQLSTATE: HY000 Message: Server is running in --secure-auth mode, but '%s'@'%s' has a password in the old format; please change the password to the new format + public final static int ER_WARN_FIELD_RESOLVED = 1276; //SQLSTATE: HY000 Message: Field or reference '%s%s%s%s%s' of SELECT #%d was resolved in SELECT #%d + @Deprecated + public final static int ER_BAD_SLAVE_UNTIL_COND = 1277; + public final static int ER_BAD_REPLICA_UNTIL_COND = 1277; //SQLSTATE: HY000 Message: Incorrect parameter or combination of parameters for START REPLICA UNTIL + @Deprecated + public final static int ER_MISSING_SKIP_SLAVE = 1278; + public final static int ER_MISSING_SKIP_REPLICA = 1278; //SQLSTATE: HY000 Message: It is recommended to use --skip-replica-start when doing step-by-step replication with START REPLICA UNTIL; otherwise, you will get problems if you get an unexpected replica's mysqld restart + public final static int ER_UNTIL_COND_IGNORED = 1279; //SQLSTATE: HY000 Message: SQL thread is not to be started so UNTIL options are ignored + public final static int ER_WRONG_NAME_FOR_INDEX = 1280; //SQLSTATE: 42000 Message: Incorrect index name '%s' + public final static int ER_WRONG_NAME_FOR_CATALOG = 1281; //SQLSTATE: 42000 Message: Incorrect catalog name '%s' + public final static int ER_WARN_QC_RESIZE = 1282; //SQLSTATE: HY000 Message: Query cache failed to set size %lu; new query cache size is %lu + public final static int ER_BAD_FT_COLUMN = 1283; //SQLSTATE: HY000 Message: Column '%s' cannot be part of FULLTEXT index + public final static int ER_UNKNOWN_KEY_CACHE = 1284; //SQLSTATE: HY000 Message: Unknown key cache '%s' + public final static int ER_WARN_HOSTNAME_WONT_WORK = 1285; //SQLSTATE: HY000 Message: MySQL is started in --skip-name-resolve mode; you must restart it without this switch for this grant to work + public final static int ER_UNKNOWN_STORAGE_ENGINE = 1286; //SQLSTATE: 42000 Message: Unknown storage engine '%s' + public final static int ER_WARN_DEPRECATED_SYNTAX = 1287; //SQLSTATE: HY000 Message: '%s' is deprecated and will be removed in a future release. Please use %s instead + public final static int ER_NON_UPDATABLE_TABLE = 1288; //SQLSTATE: HY000 Message: The target table %s of the %s is not updatable + public final static int ER_FEATURE_DISABLED = 1289; //SQLSTATE: HY000 Message: The '%s' feature is disabled; you need MySQL built with '%s' to have it working + public final static int ER_OPTION_PREVENTS_STATEMENT = 1290; //SQLSTATE: HY000 Message: The MySQL server is running with the %s option so it cannot execute this statement + public final static int ER_DUPLICATED_VALUE_IN_TYPE = 1291; //SQLSTATE: HY000 Message: Column '%s' has duplicated value '%s' in %s + public final static int ER_TRUNCATED_WRONG_VALUE = 1292; //SQLSTATE: 22007 Message: Truncated incorrect %s value: '%s' + public final static int ER_TOO_MUCH_AUTO_TIMESTAMP_COLS = 1293; //SQLSTATE: HY000 Message: Incorrect table definition; there can be only one TIMESTAMP column with CURRENT_TIMESTAMP in DEFAULT or ON UPDATE clause + public final static int ER_INVALID_ON_UPDATE = 1294; //SQLSTATE: HY000 Message: Invalid ON UPDATE clause for '%s' column + public final static int ER_UNSUPPORTED_PS = 1295; //SQLSTATE: HY000 Message: This command is not supported in the prepared statement protocol yet + public final static int ER_GET_ERRMSG = 1296; //SQLSTATE: HY000 Message: Got error %d '%s' from %s + public final static int ER_GET_TEMPORARY_ERRMSG = 1297; //SQLSTATE: HY000 Message: Got temporary error %d '%s' from %s + public final static int ER_UNKNOWN_TIME_ZONE = 1298; //SQLSTATE: HY000 Message: Unknown or incorrect time zone: '%s' + public final static int ER_WARN_INVALID_TIMESTAMP = 1299; //SQLSTATE: HY000 Message: Invalid TIMESTAMP value in column '%s' at row %ld + public final static int ER_INVALID_CHARACTER_STRING = 1300; //SQLSTATE: HY000 Message: Invalid %s character string: '%s' + public final static int ER_WARN_ALLOWED_PACKET_OVERFLOWED = 1301; //SQLSTATE: HY000 Message: Result of %s() was larger than max_allowed_packet (%ld) - truncated + public final static int ER_CONFLICTING_DECLARATIONS = 1302; //SQLSTATE: HY000 Message: Conflicting declarations: '%s%s' and '%s%s' + public final static int ER_SP_NO_RECURSIVE_CREATE = 1303; //SQLSTATE: 2F003 Message: Can't create a %s from within another stored routine + public final static int ER_SP_ALREADY_EXISTS = 1304; //SQLSTATE: 42000 Message: %s %s already exists + public final static int ER_SP_DOES_NOT_EXIST = 1305; //SQLSTATE: 42000 Message: %s %s does not exist + public final static int ER_SP_DROP_FAILED = 1306; //SQLSTATE: HY000 Message: Failed to DROP %s %s + public final static int ER_SP_STORE_FAILED = 1307; //SQLSTATE: HY000 Message: Failed to CREATE %s %s + public final static int ER_SP_LILABEL_MISMATCH = 1308; //SQLSTATE: 42000 Message: %s with no matching label: %s + public final static int ER_SP_LABEL_REDEFINE = 1309; //SQLSTATE: 42000 Message: Redefining label %s + public final static int ER_SP_LABEL_MISMATCH = 1310; //SQLSTATE: 42000 Message: End-label %s without match + public final static int ER_SP_UNINIT_VAR = 1311; //SQLSTATE: 01000 Message: Referring to uninitialized variable %s + public final static int ER_SP_BADSELECT = 1312; //SQLSTATE: 0A000 Message: PROCEDURE %s can't return a result set in the given context + public final static int ER_SP_BADRETURN = 1313; //SQLSTATE: 42000 Message: RETURN is only allowed in a FUNCTION + public final static int ER_SP_BADSTATEMENT = 1314; //SQLSTATE: 0A000 Message: %s is not allowed in stored procedures + public final static int ER_UPDATE_LOG_DEPRECATED_IGNORED = 1315; //SQLSTATE: 42000 Message: The update log is deprecated and replaced by the binary log; SET SQL_LOG_UPDATE has been ignored. This option will be removed in MySQL 5.6. + public final static int ER_UPDATE_LOG_DEPRECATED_TRANSLATED = 1316; //SQLSTATE: 42000 Message: The update log is deprecated and replaced by the binary log; SET SQL_LOG_UPDATE has been translated to SET SQL_LOG_BIN. This option will be removed in MySQL 5.6. + public final static int ER_QUERY_INTERRUPTED = 1317; //SQLSTATE: 70100 Message: Query execution was interrupted + public final static int ER_SP_WRONG_NO_OF_ARGS = 1318; //SQLSTATE: 42000 Message: Incorrect number of arguments for %s %s; expected %u, got %u + public final static int ER_SP_COND_MISMATCH = 1319; //SQLSTATE: 42000 Message: Undefined CONDITION: %s + public final static int ER_SP_NORETURN = 1320; //SQLSTATE: 42000 Message: No RETURN found in FUNCTION %s + public final static int ER_SP_NORETURNEND = 1321; //SQLSTATE: 2F005 Message: FUNCTION %s ended without RETURN + public final static int ER_SP_BAD_CURSOR_QUERY = 1322; //SQLSTATE: 42000 Message: Cursor statement must be a SELECT + public final static int ER_SP_BAD_CURSOR_SELECT = 1323; //SQLSTATE: 42000 Message: Cursor SELECT must not have INTO + public final static int ER_SP_CURSOR_MISMATCH = 1324; //SQLSTATE: 42000 Message: Undefined CURSOR: %s + public final static int ER_SP_CURSOR_ALREADY_OPEN = 1325; //SQLSTATE: 24000 Message: Cursor is already open + public final static int ER_SP_CURSOR_NOT_OPEN = 1326; //SQLSTATE: 24000 Message: Cursor is not open + public final static int ER_SP_UNDECLARED_VAR = 1327; //SQLSTATE: 42000 Message: Undeclared variable: %s + public final static int ER_SP_WRONG_NO_OF_FETCH_ARGS = 1328; //SQLSTATE: HY000 Message: Incorrect number of FETCH variables + public final static int ER_SP_FETCH_NO_DATA = 1329; //SQLSTATE: 02000 Message: No data - zero rows fetched, selected, or processed + public final static int ER_SP_DUP_PARAM = 1330; //SQLSTATE: 42000 Message: Duplicate parameter: %s + public final static int ER_SP_DUP_VAR = 1331; //SQLSTATE: 42000 Message: Duplicate variable: %s + public final static int ER_SP_DUP_COND = 1332; //SQLSTATE: 42000 Message: Duplicate condition: %s + public final static int ER_SP_DUP_CURS = 1333; //SQLSTATE: 42000 Message: Duplicate cursor: %s + public final static int ER_SP_CANT_ALTER = 1334; //SQLSTATE: HY000 Message: Failed to ALTER %s %s + public final static int ER_SP_SUBSELECT_NYI = 1335; //SQLSTATE: 0A000 Message: Subquery value not supported + public final static int ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG = 1336; //SQLSTATE: 0A000 Message: %s is not allowed in stored function or trigger + public final static int ER_SP_VARCOND_AFTER_CURSHNDLR = 1337; //SQLSTATE: 42000 Message: Variable or condition declaration after cursor or handler declaration + public final static int ER_SP_CURSOR_AFTER_HANDLER = 1338; //SQLSTATE: 42000 Message: Cursor declaration after handler declaration + public final static int ER_SP_CASE_NOT_FOUND = 1339; //SQLSTATE: 20000 Message: Case not found for CASE statement + public final static int ER_FPARSER_TOO_BIG_FILE = 1340; //SQLSTATE: HY000 Message: Configuration file '%s' is too big + public final static int ER_FPARSER_BAD_HEADER = 1341; //SQLSTATE: HY000 Message: Malformed file type header in file '%s' + public final static int ER_FPARSER_EOF_IN_COMMENT = 1342; //SQLSTATE: HY000 Message: Unexpected end of file while parsing comment '%s' + public final static int ER_FPARSER_ERROR_IN_PARAMETER = 1343; //SQLSTATE: HY000 Message: Error while parsing parameter '%s' (line: '%s') + public final static int ER_FPARSER_EOF_IN_UNKNOWN_PARAMETER = 1344; //SQLSTATE: HY000 Message: Unexpected end of file while skipping unknown parameter '%s' + public final static int ER_VIEW_NO_EXPLAIN = 1345; //SQLSTATE: HY000 Message: EXPLAIN/SHOW can not be issued; lacking privileges for underlying table + public final static int ER_FRM_UNKNOWN_TYPE = 1346; //SQLSTATE: HY000 Message: File '%s' has unknown type '%s' in its header + public final static int ER_WRONG_OBJECT = 1347; //SQLSTATE: HY000 Message: '%s.%s' is not %s + public final static int ER_NONUPDATEABLE_COLUMN = 1348; //SQLSTATE: HY000 Message: Column '%s' is not updatable + public final static int ER_VIEW_SELECT_DERIVED = 1349; //SQLSTATE: HY000 Message: View's SELECT contains a subquery in the FROM clause + public final static int ER_VIEW_SELECT_CLAUSE = 1350; //SQLSTATE: HY000 Message: View's SELECT contains a '%s' clause + public final static int ER_VIEW_SELECT_VARIABLE = 1351; //SQLSTATE: HY000 Message: View's SELECT contains a variable or parameter + public final static int ER_VIEW_SELECT_TMPTABLE = 1352; //SQLSTATE: HY000 Message: View's SELECT refers to a temporary table '%s' + public final static int ER_VIEW_WRONG_LIST = 1353; //SQLSTATE: HY000 Message: View's SELECT and view's field list have different column counts + public final static int ER_WARN_VIEW_MERGE = 1354; //SQLSTATE: HY000 Message: View merge algorithm can't be used here for now (assumed undefined algorithm) + public final static int ER_WARN_VIEW_WITHOUT_KEY = 1355; //SQLSTATE: HY000 Message: View being updated does not have complete key of underlying table in it + public final static int ER_VIEW_INVALID = 1356; //SQLSTATE: HY000 Message: View '%s.%s' references invalid table(s) or column(s) or function(s) or definer/invoker of view lack rights to use them + public final static int ER_SP_NO_DROP_SP = 1357; //SQLSTATE: HY000 Message: Can't drop or alter a %s from within another stored routine + public final static int ER_SP_GOTO_IN_HNDLR = 1358; //SQLSTATE: HY000 Message: GOTO is not allowed in a stored procedure handler + public final static int ER_TRG_ALREADY_EXISTS = 1359; //SQLSTATE: HY000 Message: Trigger already exists + public final static int ER_TRG_DOES_NOT_EXIST = 1360; //SQLSTATE: HY000 Message: Trigger does not exist + public final static int ER_TRG_ON_VIEW_OR_TEMP_TABLE = 1361; //SQLSTATE: HY000 Message: Trigger's '%s' is view or temporary table + public final static int ER_TRG_CANT_CHANGE_ROW = 1362; //SQLSTATE: HY000 Message: Updating of %s row is not allowed in %strigger + public final static int ER_TRG_NO_SUCH_ROW_IN_TRG = 1363; //SQLSTATE: HY000 Message: There is no %s row in %s trigger + public final static int ER_NO_DEFAULT_FOR_FIELD = 1364; //SQLSTATE: HY000 Message: Field '%s' doesn't have a default value + public final static int ER_DIVISION_BY_ZERO = 1365; //SQLSTATE: 22012 Message: Division by 0 + public final static int ER_TRUNCATED_WRONG_VALUE_FOR_FIELD = 1366; //SQLSTATE: HY000 Message: Incorrect %s value: '%s' for column '%s' at row %ld + public final static int ER_ILLEGAL_VALUE_FOR_TYPE = 1367; //SQLSTATE: 22007 Message: Illegal %s '%s' value found during parsing + public final static int ER_VIEW_NONUPD_CHECK = 1368; //SQLSTATE: HY000 Message: CHECK OPTION on non-updatable view '%s.%s' + public final static int ER_VIEW_CHECK_FAILED = 1369; //SQLSTATE: HY000 Message: CHECK OPTION failed '%s.%s' + public final static int ER_PROCACCESS_DENIED_ERROR = 1370; //SQLSTATE: 42000 Message: %s command denied to user '%s'@'%s' for routine '%s' + public final static int ER_RELAY_LOG_FAIL = 1371; //SQLSTATE: HY000 Message: Failed purging old relay logs: %s + public final static int ER_PASSWD_LENGTH = 1372; //SQLSTATE: HY000 Message: Password hash should be a %d-digit hexadecimal number + public final static int ER_UNKNOWN_TARGET_BINLOG = 1373; //SQLSTATE: HY000 Message: Target log not found in binlog index + public final static int ER_IO_ERR_LOG_INDEX_READ = 1374; //SQLSTATE: HY000 Message: I/O error reading log index file + public final static int ER_BINLOG_PURGE_PROHIBITED = 1375; //SQLSTATE: HY000 Message: Server configuration does not permit binlog purge + public final static int ER_FSEEK_FAIL = 1376; //SQLSTATE: HY000 Message: Failed on fseek() + public final static int ER_BINLOG_PURGE_FATAL_ERR = 1377; //SQLSTATE: HY000 Message: Fatal error during log purge + public final static int ER_LOG_IN_USE = 1378; //SQLSTATE: HY000 Message: A purgeable log is in use, will not purge + public final static int ER_LOG_PURGE_UNKNOWN_ERR = 1379; //SQLSTATE: HY000 Message: Unknown error during log purge + public final static int ER_RELAY_LOG_INIT = 1380; //SQLSTATE: HY000 Message: Failed initializing relay log position: %s + public final static int ER_NO_BINARY_LOGGING = 1381; //SQLSTATE: HY000 Message: You are not using binary logging + public final static int ER_RESERVED_SYNTAX = 1382; //SQLSTATE: HY000 Message: The '%s' syntax is reserved for purposes internal to the MySQL server + public final static int ER_WSAS_FAILED = 1383; //SQLSTATE: HY000 Message: WSAStartup Failed + public final static int ER_DIFF_GROUPS_PROC = 1384; //SQLSTATE: HY000 Message: Can't handle procedures with different groups yet + public final static int ER_NO_GROUP_FOR_PROC = 1385; //SQLSTATE: HY000 Message: Select must have a group with this procedure + public final static int ER_ORDER_WITH_PROC = 1386; //SQLSTATE: HY000 Message: Can't use ORDER clause with this procedure + public final static int ER_LOGGING_PROHIBIT_CHANGING_OF = 1387; //SQLSTATE: HY000 Message: Binary logging and replication forbid changing the global server %s + public final static int ER_NO_FILE_MAPPING = 1388; //SQLSTATE: HY000 Message: Can't map file: %s, errno: %d + public final static int ER_WRONG_MAGIC = 1389; //SQLSTATE: HY000 Message: Wrong magic in %s + public final static int ER_PS_MANY_PARAM = 1390; //SQLSTATE: HY000 Message: Prepared statement contains too many placeholders + public final static int ER_KEY_PART_0 = 1391; //SQLSTATE: HY000 Message: Key part '%s' length cannot be 0 + public final static int ER_VIEW_CHECKSUM = 1392; //SQLSTATE: HY000 Message: View text checksum failed + public final static int ER_VIEW_MULTIUPDATE = 1393; //SQLSTATE: HY000 Message: Can not modify more than one base table through a join view '%s.%s' + public final static int ER_VIEW_NO_INSERT_FIELD_LIST = 1394; //SQLSTATE: HY000 Message: Can not insert into join view '%s.%s' without fields list + public final static int ER_VIEW_DELETE_MERGE_VIEW = 1395; //SQLSTATE: HY000 Message: Can not delete from join view '%s.%s' + public final static int ER_CANNOT_USER = 1396; //SQLSTATE: HY000 Message: Operation %s failed for %s + public final static int ER_XAER_NOTA = 1397; //SQLSTATE: XAE04 Message: XAER_NOTA: Unknown XID + public final static int ER_XAER_INVAL = 1398; //SQLSTATE: XAE05 Message: XAER_INVAL: Invalid arguments (or unsupported command) + public final static int ER_XAER_RMFAIL = 1399; //SQLSTATE: XAE07 Message: XAER_RMFAIL: The command cannot be executed when global transaction is in the %s state + public final static int ER_XAER_OUTSIDE = 1400; //SQLSTATE: XAE09 Message: XAER_OUTSIDE: Some work is done outside global transaction + public final static int ER_XA_RMERR = 1401; + public final static int ER_XA_RBROLLBACK = 1402; //SQLSTATE: XA100 Message: XA_RBROLLBACK: Transaction branch was rolled back + public final static int ER_NONEXISTING_PROC_GRANT = 1403; //SQLSTATE: 42000 Message: There is no such grant defined for user '%s' on host '%s' on routine '%s' + public final static int ER_PROC_AUTO_GRANT_FAIL = 1404; //SQLSTATE: HY000 Message: Failed to grant EXECUTE and ALTER ROUTINE privileges + public final static int ER_PROC_AUTO_REVOKE_FAIL = 1405; //SQLSTATE: HY000 Message: Failed to revoke all privileges to dropped routine + public final static int ER_DATA_TOO_LONG = 1406; //SQLSTATE: 22001 Message: Data too long for column '%s' at row %ld + public final static int ER_SP_BAD_SQLSTATE = 1407; //SQLSTATE: 42000 Message: Bad; //SQLSTATE: '%s' + public final static int ER_STARTUP = 1408; //SQLSTATE: HY000 Message: %s: ready for connections. Version: '%s' socket: '%s' port: %d %s + public final static int ER_LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR = 1409; //SQLSTATE: HY000 Message: Can't load value from file with fixed size rows to variable + public final static int ER_CANT_CREATE_USER_WITH_GRANT = 1410; //SQLSTATE: 42000 Message: You are not allowed to create a user with GRANT + public final static int ER_WRONG_VALUE_FOR_TYPE = 1411; //SQLSTATE: HY000 Message: Incorrect %s value: '%s' for function %s + public final static int ER_TABLE_DEF_CHANGED = 1412; //SQLSTATE: HY000 Message: Table definition has changed, please retry transaction + public final static int ER_SP_DUP_HANDLER = 1413; //SQLSTATE: 42000 Message: Duplicate handler declared in the same block + public final static int ER_SP_NOT_VAR_ARG = 1414; //SQLSTATE: 42000 Message: OUT or INOUT argument %d for routine %s is not a variable or NEW pseudo-variable in BEFORE trigger + public final static int ER_SP_NO_RETSET = 1415; //SQLSTATE: 0A000 Message: Not allowed to return a result set from a %s + public final static int ER_CANT_CREATE_GEOMETRY_OBJECT = 1416; //SQLSTATE: 22003 Message: Cannot get geometry object from data you send to the GEOMETRY field + public final static int ER_FAILED_ROUTINE_BREAK_BINLOG = 1417; //SQLSTATE: HY000 Message: A routine failed and has neither NO SQL nor READS SQL DATA in its declaration and binary logging is enabled; if non-transactional tables were updated, the binary log will miss their changes + public final static int ER_BINLOG_UNSAFE_ROUTINE = 1418; //SQLSTATE: HY000 Message: This function has none of DETERMINISTIC, NO SQL, or READS SQL DATA in its declaration and binary logging is enabled (you *might* want to use the less safe log_bin_trust_function_creators variable) + public final static int ER_BINLOG_CREATE_ROUTINE_NEED_SUPER = 1419; //SQLSTATE: HY000 Message: You do not have the SUPER privilege and binary logging is enabled (you *might* want to use the less safe log_bin_trust_function_creators variable) + public final static int ER_EXEC_STMT_WITH_OPEN_CURSOR = 1420; //SQLSTATE: HY000 Message: You can't execute a prepared statement which has an open cursor associated with it. Reset the statement to re-execute it. + public final static int ER_STMT_HAS_NO_OPEN_CURSOR = 1421; //SQLSTATE: HY000 Message: The statement (%lu) has no open cursor. + public final static int ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG = 1422; //SQLSTATE: HY000 Message: Explicit or implicit commit is not allowed in stored function or trigger. + public final static int ER_NO_DEFAULT_FOR_VIEW_FIELD = 1423; //SQLSTATE: HY000 Message: Field of view '%s.%s' underlying table doesn't have a default value + public final static int ER_SP_NO_RECURSION = 1424; //SQLSTATE: HY000 Message: Recursive stored functions and triggers are not allowed. + public final static int ER_TOO_BIG_SCALE = 1425; //SQLSTATE: 42000 Message: Too big scale %d specified for column '%s'. Maximum is %lu. + public final static int ER_TOO_BIG_PRECISION = 1426; //SQLSTATE: 42000 Message: Too big precision %d specified for column '%s'. Maximum is %lu. + public final static int ER_M_BIGGER_THAN_D = 1427; //SQLSTATE: 42000 Message: For float(M,D), double(M,D) or decimal(M,D), M must be >= D (column '%s'). + public final static int ER_WRONG_LOCK_OF_SYSTEM_TABLE = 1428; //SQLSTATE: HY000 Message: You can't combine write-locking of system tables with other tables or lock types + public final static int ER_CONNECT_TO_FOREIGN_DATA_SOURCE = 1429; //SQLSTATE: HY000 Message: Unable to connect to foreign data source: %s + public final static int ER_QUERY_ON_FOREIGN_DATA_SOURCE = 1430; //SQLSTATE: HY000 Message: There was a problem processing the query on the foreign data source. Data source error: %s + public final static int ER_FOREIGN_DATA_SOURCE_DOESNT_EXIST = 1431; //SQLSTATE: HY000 Message: The foreign data source you are trying to reference does not exist. Data source error: %s + public final static int ER_FOREIGN_DATA_STRING_INVALID_CANT_CREATE = 1432; //SQLSTATE: HY000 Message: Can't create federated table. The data source connection string '%s' is not in the correct format + public final static int ER_FOREIGN_DATA_STRING_INVALID = 1433; //SQLSTATE: HY000 Message: The data source connection string '%s' is not in the correct format + public final static int ER_CANT_CREATE_FEDERATED_TABLE = 1434; //SQLSTATE: HY000 Message: Can't create federated table. Foreign data src error: %s + public final static int ER_TRG_IN_WRONG_SCHEMA = 1435; //SQLSTATE: HY000 Message: Trigger in wrong schema + public final static int ER_STACK_OVERRUN_NEED_MORE = 1436; //SQLSTATE: HY000 Message: Thread stack overrun: %ld bytes used of a %ld byte stack, and %ld bytes needed. Use 'mysqld --thread_stack=#' to specify a bigger stack. + public final static int ER_TOO_LONG_BODY = 1437; //SQLSTATE: 42000 Message: Routine body for '%s' is too long + public final static int ER_WARN_CANT_DROP_DEFAULT_KEYCACHE = 1438; //SQLSTATE: HY000 Message: Cannot drop default keycache + public final static int ER_TOO_BIG_DISPLAYWIDTH = 1439; //SQLSTATE: 42000 Message: Display width out of range for column '%s' (max = %lu) + public final static int ER_XAER_DUPID = 1440; //SQLSTATE: XAE08 Message: XAER_DUPID: The XID already exists + public final static int ER_DATETIME_FUNCTION_OVERFLOW = 1441; //SQLSTATE: 22008 Message: Datetime function: %s field overflow + public final static int ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG = 1442; //SQLSTATE: HY000 Message: Can't update table '%s' in stored function/trigger because it is already used by statement which invoked this stored function/trigger. + public final static int ER_VIEW_PREVENT_UPDATE = 1443; //SQLSTATE: HY000 Message: The definition of table '%s' prevents operation %s on table '%s'. + public final static int ER_PS_NO_RECURSION = 1444; //SQLSTATE: HY000 Message: The prepared statement contains a stored routine call that refers to that same statement. It's not allowed to execute a prepared statement in such a recursive manner + public final static int ER_SP_CANT_SET_AUTOCOMMIT = 1445; //SQLSTATE: HY000 Message: Not allowed to set autocommit from a stored function or trigger + public final static int ER_MALFORMED_DEFINER = 1446; //SQLSTATE: HY000 Message: Definer is not fully qualified + public final static int ER_VIEW_FRM_NO_USER = 1447; //SQLSTATE: HY000 Message: View '%s'.'%s' has no definer information (old table format). Current user is used as definer. Please recreate the view! + public final static int ER_VIEW_OTHER_USER = 1448; //SQLSTATE: HY000 Message: You need the SUPER privilege for creation view with '%s'@'%s' definer + public final static int ER_NO_SUCH_USER = 1449; //SQLSTATE: HY000 Message: The user specified as a definer ('%s'@'%s') does not exist + public final static int ER_FORBID_SCHEMA_CHANGE = 1450; //SQLSTATE: HY000 Message: Changing schema from '%s' to '%s' is not allowed. + public final static int ER_ROW_IS_REFERENCED_2 = 1451; //SQLSTATE: 23000 Message: Cannot delete or update a parent row: a foreign key constraint fails (%s) + public final static int ER_NO_REFERENCED_ROW_2 = 1452; //SQLSTATE: 23000 Message: Cannot add or update a child row: a foreign key constraint fails (%s) + public final static int ER_SP_BAD_VAR_SHADOW = 1453; //SQLSTATE: 42000 Message: Variable '%s' must be quoted with `...`, or renamed + public final static int ER_TRG_NO_DEFINER = 1454; //SQLSTATE: HY000 Message: No definer attribute for trigger '%s'.'%s'. The trigger will be activated under the authorization of the invoker, which may have insufficient privileges. Please recreate the trigger. + public final static int ER_OLD_FILE_FORMAT = 1455; //SQLSTATE: HY000 Message: '%s' has an old format, you should re-create the '%s' object(s) + public final static int ER_SP_RECURSION_LIMIT = 1456; //SQLSTATE: HY000 Message: Recursive limit %d (as set by the max_sp_recursion_depth variable) was exceeded for routine %s + public final static int ER_SP_PROC_TABLE_CORRUPT = 1457; //SQLSTATE: HY000 Message: Failed to load routine %s. The table mysql.proc is missing, corrupt, or contains bad data (internal code %d) + public final static int ER_SP_WRONG_NAME = 1458; //SQLSTATE: 42000 Message: Incorrect routine name '%s' + public final static int ER_TABLE_NEEDS_UPGRADE = 1459; //SQLSTATE: HY000 Message: Table upgrade required. Please do "REPAIR TABLE `%s`" or dump/reload to fix it! + public final static int ER_SP_NO_AGGREGATE = 1460; //SQLSTATE: 42000 Message: AGGREGATE is not supported for stored functions + public final static int ER_MAX_PREPARED_STMT_COUNT_REACHED = 1461; //SQLSTATE: 42000 Message: Can't create more than max_prepared_stmt_count statements (current value: %lu) + public final static int ER_VIEW_RECURSIVE = 1462; //SQLSTATE: HY000 Message: `%s`.`%s` contains view recursion + public final static int ER_NON_GROUPING_FIELD_USED = 1463; //SQLSTATE: 42000 Message: non-grouping field '%s' is used in %s clause + public final static int ER_TABLE_CANT_HANDLE_SPKEYS = 1464; //SQLSTATE: HY000 Message: The used table type doesn't support SPATIAL indexes + public final static int ER_NO_TRIGGERS_ON_SYSTEM_SCHEMA = 1465; //SQLSTATE: HY000 Message: Triggers can not be created on system tables + public final static int ER_REMOVED_SPACES = 1466; //SQLSTATE: HY000 Message: Leading spaces are removed from name '%s' + public final static int ER_AUTOINC_READ_FAILED = 1467; //SQLSTATE: HY000 Message: Failed to read auto-increment value from storage engine + public final static int ER_USERNAME = 1468; //SQLSTATE: HY000 Message: user name + public final static int ER_HOSTNAME = 1469; //SQLSTATE: HY000 Message: host name + public final static int ER_WRONG_STRING_LENGTH = 1470; //SQLSTATE: HY000 Message: String '%s' is too long for %s (should be no longer than %d) + public final static int ER_NON_INSERTABLE_TABLE = 1471; //SQLSTATE: HY000 Message: The target table %s of the %s is not insertable-into + public final static int ER_ADMIN_WRONG_MRG_TABLE = 1472; //SQLSTATE: HY000 Message: Table '%s' is differently defined or of non-MyISAM type or doesn't exist + public final static int ER_TOO_HIGH_LEVEL_OF_NESTING_FOR_SELECT = 1473; //SQLSTATE: HY000 Message: Too high level of nesting for select + public final static int ER_NAME_BECOMES_EMPTY = 1474; //SQLSTATE: HY000 Message: Name '%s' has become '' + public final static int ER_AMBIGUOUS_FIELD_TERM = 1475; //SQLSTATE: HY000 Message: First character of the FIELDS TERMINATED string is ambiguous; please use non-optional and non-empty FIELDS ENCLOSED BY + public final static int ER_FOREIGN_SERVER_EXISTS = 1476; //SQLSTATE: HY000 Message: The foreign server, %s, you are trying to create already exists. + public final static int ER_FOREIGN_SERVER_DOESNT_EXIST = 1477; //SQLSTATE: HY000 Message: The foreign server name you are trying to reference does not exist. Data source error: %s + public final static int ER_ILLEGAL_HA_CREATE_OPTION = 1478; //SQLSTATE: HY000 Message: Table storage engine '%s' does not support the create option '%s' + public final static int ER_PARTITION_REQUIRES_VALUES_ERROR = 1479; //SQLSTATE: HY000 Message: Syntax error: %s PARTITIONING requires definition of VALUES %s for each partition + public final static int ER_PARTITION_WRONG_VALUES_ERROR = 1480; //SQLSTATE: HY000 Message: Only %s PARTITIONING can use VALUES %s in partition definition + public final static int ER_PARTITION_MAXVALUE_ERROR = 1481; //SQLSTATE: HY000 Message: MAXVALUE can only be used in last partition definition + public final static int ER_PARTITION_SUBPARTITION_ERROR = 1482; //SQLSTATE: HY000 Message: Subpartitions can only be hash partitions and by key + public final static int ER_PARTITION_SUBPART_MIX_ERROR = 1483; //SQLSTATE: HY000 Message: Must define subpartitions on all partitions if on one partition + public final static int ER_PARTITION_WRONG_NO_PART_ERROR = 1484; //SQLSTATE: HY000 Message: Wrong number of partitions defined, mismatch with previous setting + public final static int ER_PARTITION_WRONG_NO_SUBPART_ERROR = 1485; //SQLSTATE: HY000 Message: Wrong number of subpartitions defined, mismatch with previous setting + public final static int ER_WRONG_EXPR_IN_PARTITION_FUNC_ERROR = 1486; //SQLSTATE: HY000 Message: Constant, random or timezone-dependent expressions in (sub)partitioning function are not allowed + public final static int ER_NO_CONST_EXPR_IN_RANGE_OR_LIST_ERROR = 1487; //SQLSTATE: HY000 Message: Expression in RANGE/LIST VALUES must be constant + public final static int ER_FIELD_NOT_FOUND_PART_ERROR = 1488; //SQLSTATE: HY000 Message: Field in list of fields for partition function not found in table + public final static int ER_LIST_OF_FIELDS_ONLY_IN_HASH_ERROR = 1489; //SQLSTATE: HY000 Message: List of fields is only allowed in KEY partitions + public final static int ER_INCONSISTENT_PARTITION_INFO_ERROR = 1490; //SQLSTATE: HY000 Message: The partition info in the frm file is not consistent with what can be written into the frm file + public final static int ER_PARTITION_FUNC_NOT_ALLOWED_ERROR = 1491; //SQLSTATE: HY000 Message: The %s function returns the wrong type + public final static int ER_PARTITIONS_MUST_BE_DEFINED_ERROR = 1492; //SQLSTATE: HY000 Message: For %s partitions each partition must be defined + public final static int ER_RANGE_NOT_INCREASING_ERROR = 1493; //SQLSTATE: HY000 Message: VALUES LESS THAN value must be strictly increasing for each partition + public final static int ER_INCONSISTENT_TYPE_OF_FUNCTIONS_ERROR = 1494; //SQLSTATE: HY000 Message: VALUES value must be of same type as partition function + public final static int ER_MULTIPLE_DEF_CONST_IN_LIST_PART_ERROR = 1495; //SQLSTATE: HY000 Message: Multiple definition of same constant in list partitioning + public final static int ER_PARTITION_ENTRY_ERROR = 1496; //SQLSTATE: HY000 Message: Partitioning can not be used stand-alone in query + public final static int ER_MIX_HANDLER_ERROR = 1497; //SQLSTATE: HY000 Message: The mix of handlers in the partitions is not allowed in this version of MySQL + public final static int ER_PARTITION_NOT_DEFINED_ERROR = 1498; //SQLSTATE: HY000 Message: For the partitioned engine it is necessary to define all %s + public final static int ER_TOO_MANY_PARTITIONS_ERROR = 1499; //SQLSTATE: HY000 Message: Too many partitions (including subpartitions) were defined + public final static int ER_SUBPARTITION_ERROR = 1500; //SQLSTATE: HY000 Message: It is only possible to mix RANGE/LIST partitioning with HASH/KEY partitioning for subpartitioning + public final static int ER_CANT_CREATE_HANDLER_FILE = 1501; //SQLSTATE: HY000 Message: Failed to create specific handler file + public final static int ER_BLOB_FIELD_IN_PART_FUNC_ERROR = 1502; //SQLSTATE: HY000 Message: A BLOB field is not allowed in partition function + public final static int ER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF = 1503; //SQLSTATE: HY000 Message: A %s must include all columns in the table's partitioning function + public final static int ER_NO_PARTS_ERROR = 1504; //SQLSTATE: HY000 Message: Number of %s = 0 is not an allowed value + public final static int ER_PARTITION_MGMT_ON_NONPARTITIONED = 1505; //SQLSTATE: HY000 Message: Partition management on a not partitioned table is not possible + public final static int ER_FOREIGN_KEY_ON_PARTITIONED = 1506; //SQLSTATE: HY000 Message: Foreign key clause is not yet supported in conjunction with partitioning + public final static int ER_DROP_PARTITION_NON_EXISTENT = 1507; //SQLSTATE: HY000 Message: Error in list of partitions to %s + public final static int ER_DROP_LAST_PARTITION = 1508; //SQLSTATE: HY000 Message: Cannot remove all partitions, use DROP TABLE instead + public final static int ER_COALESCE_ONLY_ON_HASH_PARTITION = 1509; //SQLSTATE: HY000 Message: COALESCE PARTITION can only be used on HASH/KEY partitions + public final static int ER_REORG_HASH_ONLY_ON_SAME_NO = 1510; //SQLSTATE: HY000 Message: REORGANIZE PARTITION can only be used to reorganize partitions not to change their numbers + public final static int ER_REORG_NO_PARAM_ERROR = 1511; //SQLSTATE: HY000 Message: REORGANIZE PARTITION without parameters can only be used on auto-partitioned tables using HASH PARTITIONs + public final static int ER_ONLY_ON_RANGE_LIST_PARTITION = 1512; //SQLSTATE: HY000 Message: %s PARTITION can only be used on RANGE/LIST partitions + public final static int ER_ADD_PARTITION_SUBPART_ERROR = 1513; //SQLSTATE: HY000 Message: Trying to Add partition(s) with wrong number of subpartitions + public final static int ER_ADD_PARTITION_NO_NEW_PARTITION = 1514; //SQLSTATE: HY000 Message: At least one partition must be added + public final static int ER_COALESCE_PARTITION_NO_PARTITION = 1515; //SQLSTATE: HY000 Message: At least one partition must be coalesced + public final static int ER_REORG_PARTITION_NOT_EXIST = 1516; //SQLSTATE: HY000 Message: More partitions to reorganize than there are partitions + public final static int ER_SAME_NAME_PARTITION = 1517; //SQLSTATE: HY000 Message: Duplicate partition name %s + public final static int ER_NO_BINLOG_ERROR = 1518; //SQLSTATE: HY000 Message: It is not allowed to shut off binlog on this command + public final static int ER_CONSECUTIVE_REORG_PARTITIONS = 1519; //SQLSTATE: HY000 Message: When reorganizing a set of partitions they must be in consecutive order + public final static int ER_REORG_OUTSIDE_RANGE = 1520; //SQLSTATE: HY000 Message: Reorganize of range partitions cannot change total ranges except for last partition where it can extend the range + public final static int ER_PARTITION_FUNCTION_FAILURE = 1521; //SQLSTATE: HY000 Message: Partition function not supported in this version for this handler + public final static int ER_PART_STATE_ERROR = 1522; //SQLSTATE: HY000 Message: Partition state cannot be defined from CREATE/ALTER TABLE + public final static int ER_LIMITED_PART_RANGE = 1523; //SQLSTATE: HY000 Message: The %s handler only supports 32 bit integers in VALUES + public final static int ER_PLUGIN_IS_NOT_LOADED = 1524; //SQLSTATE: HY000 Message: Plugin '%s' is not loaded + public final static int ER_WRONG_VALUE = 1525; //SQLSTATE: HY000 Message: Incorrect %s value: '%s' + public final static int ER_NO_PARTITION_FOR_GIVEN_VALUE = 1526; //SQLSTATE: HY000 Message: Table has no partition for value %s + public final static int ER_FILEGROUP_OPTION_ONLY_ONCE = 1527; //SQLSTATE: HY000 Message: It is not allowed to specify %s more than once + public final static int ER_CREATE_FILEGROUP_FAILED = 1528; //SQLSTATE: HY000 Message: Failed to create %s + public final static int ER_DROP_FILEGROUP_FAILED = 1529; //SQLSTATE: HY000 Message: Failed to drop %s + public final static int ER_TABLESPACE_AUTO_EXTEND_ERROR = 1530; //SQLSTATE: HY000 Message: The handler doesn't support autoextend of tablespaces + public final static int ER_WRONG_SIZE_NUMBER = 1531; //SQLSTATE: HY000 Message: A size parameter was incorrectly specified, either number or on the form 10M + public final static int ER_SIZE_OVERFLOW_ERROR = 1532; //SQLSTATE: HY000 Message: The size number was correct but we don't allow the digit part to be more than 2 billion + public final static int ER_ALTER_FILEGROUP_FAILED = 1533; //SQLSTATE: HY000 Message: Failed to alter: %s + public final static int ER_BINLOG_ROW_LOGGING_FAILED = 1534; //SQLSTATE: HY000 Message: Writing one row to the row-based binary log failed + public final static int ER_BINLOG_ROW_WRONG_TABLE_DEF = 1535; //SQLSTATE: HY000 Message: Table definition on source and replica does not match: %s + public final static int ER_BINLOG_ROW_RBR_TO_SBR = 1536; //SQLSTATE: HY000 Message: Replica running with --log-replica-updates must use row-based binary logging to be able to replicate row-based binary log events + public final static int ER_EVENT_ALREADY_EXISTS = 1537; //SQLSTATE: HY000 Message: Event '%s' already exists + public final static int ER_EVENT_STORE_FAILED = 1538; //SQLSTATE: HY000 Message: Failed to store event %s. Error code %d from storage engine. + public final static int ER_EVENT_DOES_NOT_EXIST = 1539; //SQLSTATE: HY000 Message: Unknown event '%s' + public final static int ER_EVENT_CANT_ALTER = 1540; //SQLSTATE: HY000 Message: Failed to alter event '%s' + public final static int ER_EVENT_DROP_FAILED = 1541; //SQLSTATE: HY000 Message: Failed to drop %s + public final static int ER_EVENT_INTERVAL_NOT_POSITIVE_OR_TOO_BIG = 1542; //SQLSTATE: HY000 Message: INTERVAL is either not positive or too big + public final static int ER_EVENT_ENDS_BEFORE_STARTS = 1543; //SQLSTATE: HY000 Message: ENDS is either invalid or before STARTS + public final static int ER_EVENT_EXEC_TIME_IN_THE_PAST = 1544; //SQLSTATE: HY000 Message: Event execution time is in the past. Event has been disabled + public final static int ER_EVENT_OPEN_TABLE_FAILED = 1545; //SQLSTATE: HY000 Message: Failed to open mysql.event + public final static int ER_EVENT_NEITHER_M_EXPR_NOR_M_AT = 1546; //SQLSTATE: HY000 Message: No datetime expression provided + public final static int ER_COL_COUNT_DOESNT_MATCH_CORRUPTED = 1547; //SQLSTATE: HY000 Message: Column count of mysql.%s is wrong. Expected %d, found %d. The table is probably corrupted + public final static int ER_CANNOT_LOAD_FROM_TABLE = 1548; //SQLSTATE: HY000 Message: Cannot load from mysql.%s. The table is probably corrupted + public final static int ER_EVENT_CANNOT_DELETE = 1549; //SQLSTATE: HY000 Message: Failed to delete the event from mysql.event + public final static int ER_EVENT_COMPILE_ERROR = 1550; //SQLSTATE: HY000 Message: Error during compilation of event's body + public final static int ER_EVENT_SAME_NAME = 1551; //SQLSTATE: HY000 Message: Same old and new event name + public final static int ER_EVENT_DATA_TOO_LONG = 1552; //SQLSTATE: HY000 Message: Data for column '%s' too long + public final static int ER_DROP_INDEX_FK = 1553; //SQLSTATE: HY000 Message: Cannot drop index '%s': needed in a foreign key constraint + public final static int ER_WARN_DEPRECATED_SYNTAX_WITH_VER = 1554; //SQLSTATE: HY000 Message: The syntax '%s' is deprecated and will be removed in MySQL %s. Please use %s instead + public final static int ER_CANT_WRITE_LOCK_LOG_TABLE = 1555; //SQLSTATE: HY000 Message: You can't write-lock a log table. Only read access is possible + public final static int ER_CANT_LOCK_LOG_TABLE = 1556; //SQLSTATE: HY000 Message: You can't use locks with log tables. + public final static int ER_FOREIGN_DUPLICATE_KEY = 1557; //SQLSTATE: 23000 Message: Upholding foreign key constraints for table '%s', entry '%s', key %d would lead to a duplicate entry + public final static int ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE = 1558; //SQLSTATE: HY000 Message: Column count of mysql.%s is wrong. Expected %d, found %d. Created with MySQL %d, now running %d. Please use mysql_upgrade to fix this error. + public final static int ER_TEMP_TABLE_PREVENTS_SWITCH_OUT_OF_RBR = 1559; //SQLSTATE: HY000 Message: Cannot switch out of the row-based binary log format when the session has open temporary tables + public final static int ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_FORMAT = 1560; //SQLSTATE: HY000 Message: Cannot change the binary logging format inside a stored function or trigger + public final static int ER_NDB_CANT_SWITCH_BINLOG_FORMAT = 1561; //SQLSTATE: HY000 Message: The NDB cluster engine does not support changing the binlog format on the fly yet + public final static int ER_PARTITION_NO_TEMPORARY = 1562; //SQLSTATE: HY000 Message: Cannot create temporary table with partitions + public final static int ER_PARTITION_CONST_DOMAIN_ERROR = 1563; //SQLSTATE: HY000 Message: Partition constant is out of partition function domain + public final static int ER_PARTITION_FUNCTION_IS_NOT_ALLOWED = 1564; //SQLSTATE: HY000 Message: This partition function is not allowed + public final static int ER_DDL_LOG_ERROR = 1565; //SQLSTATE: HY000 Message: Error in DDL log + public final static int ER_NULL_IN_VALUES_LESS_THAN = 1566; //SQLSTATE: HY000 Message: Not allowed to use NULL value in VALUES LESS THAN + public final static int ER_WRONG_PARTITION_NAME = 1567; //SQLSTATE: HY000 Message: Incorrect partition name + public final static int ER_CANT_CHANGE_TX_ISOLATION = 1568; //SQLSTATE: 25001 Message: Transaction isolation level can't be changed while a transaction is in progress + public final static int ER_DUP_ENTRY_AUTOINCREMENT_CASE = 1569; //SQLSTATE: HY000 Message: ALTER TABLE causes auto_increment resequencing, resulting in duplicate entry '%s' for key '%s' + public final static int ER_EVENT_MODIFY_QUEUE_ERROR = 1570; //SQLSTATE: HY000 Message: Internal scheduler error %d + public final static int ER_EVENT_SET_VAR_ERROR = 1571; //SQLSTATE: HY000 Message: Error during starting/stopping of the scheduler. Error code %u + public final static int ER_PARTITION_MERGE_ERROR = 1572; //SQLSTATE: HY000 Message: Engine cannot be used in partitioned tables + public final static int ER_CANT_ACTIVATE_LOG = 1573; //SQLSTATE: HY000 Message: Cannot activate '%s' log + public final static int ER_RBR_NOT_AVAILABLE = 1574; //SQLSTATE: HY000 Message: The server was not built with row-based replication + public final static int ER_BASE64_DECODE_ERROR = 1575; //SQLSTATE: HY000 Message: Decoding of base64 string failed + public final static int ER_EVENT_RECURSION_FORBIDDEN = 1576; //SQLSTATE: HY000 Message: Recursion of EVENT DDL statements is forbidden when body is present + public final static int ER_EVENTS_DB_ERROR = 1577; //SQLSTATE: HY000 Message: Cannot proceed because system tables used by Event Scheduler were found damaged at server start + public final static int ER_ONLY_INTEGERS_ALLOWED = 1578; //SQLSTATE: HY000 Message: Only integers allowed as number here + public final static int ER_UNSUPORTED_LOG_ENGINE = 1579; //SQLSTATE: HY000 Message: This storage engine cannot be used for log tables" + public final static int ER_BAD_LOG_STATEMENT = 1580; //SQLSTATE: HY000 Message: You cannot '%s' a log table if logging is enabled + public final static int ER_CANT_RENAME_LOG_TABLE = 1581; //SQLSTATE: HY000 Message: Cannot rename '%s'. When logging enabled, rename to/from log table must rename two tables: the log table to an archive table and another table back to '%s' + public final static int ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT = 1582; //SQLSTATE: 42000 Message: Incorrect parameter count in the call to native function '%s' + public final static int ER_WRONG_PARAMETERS_TO_NATIVE_FCT = 1583; //SQLSTATE: 42000 Message: Incorrect parameters in the call to native function '%s' + public final static int ER_WRONG_PARAMETERS_TO_STORED_FCT = 1584; //SQLSTATE: 42000 Message: Incorrect parameters in the call to stored function '%s' + public final static int ER_NATIVE_FCT_NAME_COLLISION = 1585; //SQLSTATE: HY000 Message: This function '%s' has the same name as a native function + public final static int ER_DUP_ENTRY_WITH_KEY_NAME = 1586; //SQLSTATE: 23000 Message: Duplicate entry '%s' for key '%s' + public final static int ER_BINLOG_PURGE_EMFILE = 1587; //SQLSTATE: HY000 Message: Too many files opened, please execute the command again + public final static int ER_EVENT_CANNOT_CREATE_IN_THE_PAST = 1588; //SQLSTATE: HY000 Message: Event execution time is in the past and ON COMPLETION NOT PRESERVE is set. The event was dropped immediately after creation. + public final static int ER_EVENT_CANNOT_ALTER_IN_THE_PAST = 1589; //SQLSTATE: HY000 Message: Event execution time is in the past and ON COMPLETION NOT PRESERVE is set. The event was dropped immediately after creation. + @Deprecated + public final static int ER_SLAVE_INCIDENT = 1590; + public final static int ER_REPLICA_INCIDENT = 1590; //SQLSTATE: HY000 Message: The incident %s occured on the source. Message: %s + public final static int ER_NO_PARTITION_FOR_GIVEN_VALUE_SILENT = 1591; //SQLSTATE: HY000 Message: Table has no partition for some existing values + public final static int ER_BINLOG_UNSAFE_STATEMENT = 1592; //SQLSTATE: HY000 Message: Unsafe statement written to the binary log using statement format since BINLOG_FORMAT = STATEMENT. %s + @Deprecated + public final static int ER_SLAVE_FATAL_ERROR = 1593; + public final static int ER_REPLICA_FATAL_ERROR = 1593; //SQLSTATE: HY000 Message: Fatal error: %s + @Deprecated + public final static int ER_SLAVE_RELAY_LOG_READ_FAILURE = 1594; + public final static int ER_REPLICA_RELAY_LOG_READ_FAILURE = 1594; //SQLSTATE: HY000 Message: Relay log read failure: %s + @Deprecated + public final static int ER_SLAVE_RELAY_LOG_WRITE_FAILURE = 1595; + public final static int ER_REPLICA_RELAY_LOG_WRITE_FAILURE = 1595; //SQLSTATE: HY000 Message: Relay log write failure: %s + @Deprecated + public final static int ER_SLAVE_CREATE_EVENT_FAILURE = 1596; + public final static int ER_REPLICA_CREATE_EVENT_FAILURE = 1596; //SQLSTATE: HY000 Message: Failed to create %s + @Deprecated + public final static int ER_SLAVE_MASTER_COM_FAILURE = 1597; + public final static int ER_REPLICA_SOURCE_COM_FAILURE = 1597; //SQLSTATE: HY000 Message: Source command %s failed: %s + public final static int ER_BINLOG_LOGGING_IMPOSSIBLE = 1598; //SQLSTATE: HY000 Message: Binary logging not possible. Message: %s + public final static int ER_VIEW_NO_CREATION_CTX = 1599; //SQLSTATE: HY000 Message: View `%s`.`%s` has no creation context + public final static int ER_VIEW_INVALID_CREATION_CTX = 1600; //SQLSTATE: HY000 Message: Creation context of view `%s`.`%s' is invalid + public final static int ER_SR_INVALID_CREATION_CTX = 1601; //SQLSTATE: HY000 Message: Creation context of stored routine `%s`.`%s` is invalid + public final static int ER_TRG_CORRUPTED_FILE = 1602; //SQLSTATE: HY000 Message: Corrupted TRG file for table `%s`.`%s` + public final static int ER_TRG_NO_CREATION_CTX = 1603; //SQLSTATE: HY000 Message: Triggers for table `%s`.`%s` have no creation context + public final static int ER_TRG_INVALID_CREATION_CTX = 1604; //SQLSTATE: HY000 Message: Trigger creation context of table `%s`.`%s` is invalid + public final static int ER_EVENT_INVALID_CREATION_CTX = 1605; //SQLSTATE: HY000 Message: Creation context of event `%s`.`%s` is invalid + public final static int ER_TRG_CANT_OPEN_TABLE = 1606; //SQLSTATE: HY000 Message: Cannot open table for trigger `%s`.`%s` + public final static int ER_CANT_CREATE_SROUTINE = 1607; //SQLSTATE: HY000 Message: Cannot create stored routine `%s`. Check warnings + public final static int ER_NEVER_USED = 1608; //SQLSTATE: HY000 Message: Ambiguous replica modes combination. %s + public final static int ER_NO_FORMAT_DESCRIPTION_EVENT_BEFORE_BINLOG_STATEMENT = 1609; //SQLSTATE: HY000 Message: The BINLOG statement of type `%s` was not preceded by a format description BINLOG statement. + @Deprecated + public final static int ER_SLAVE_CORRUPT_EVENT = 1610; + public final static int ER_REPLICA_CORRUPT_EVENT = 1610; //SQLSTATE: HY000 Message: Corrupted replication event was detected + public final static int ER_LOAD_DATA_INVALID_COLUMN = 1611; //SQLSTATE: HY000 Message: Invalid column reference (%s) in LOAD DATA + public final static int ER_LOG_PURGE_NO_FILE = 1612; //SQLSTATE: HY000 Message: Being purged log %s was not found + public final static int ER_XA_RBTIMEOUT = 1613; //SQLSTATE: XA106 Message: XA_RBTIMEOUT: Transaction branch was rolled back: took too long + public final static int ER_XA_RBDEADLOCK = 1614; //SQLSTATE: XA102 Message: XA_RBDEADLOCK: Transaction branch was rolled back: deadlock was detected + public final static int ER_NEED_REPREPARE = 1615; //SQLSTATE: HY000 Message: Prepared statement needs to be re-prepared + public final static int ER_DELAYED_NOT_SUPPORTED = 1616; //SQLSTATE: HY000 Message: DELAYED option not supported for table '%s' + @Deprecated + public final static int WARN_NO_MASTER_INFO = 1617; + public final static int WARN_NO_SOURCE_INFO = 1617; //SQLSTATE: HY000 Message: The source info structure does not exist + public final static int WARN_OPTION_IGNORED = 1618; //SQLSTATE: HY000 Message: <%s> option ignored + public final static int WARN_PLUGIN_DELETE_BUILTIN = 1619; //SQLSTATE: HY000 Message: Built-in plugins cannot be deleted + public final static int WARN_PLUGIN_BUSY = 1620; //SQLSTATE: HY000 Message: Plugin is busy and will be uninstalled on shutdown + public final static int ER_VARIABLE_IS_READONLY = 1621; //SQLSTATE: HY000 Message: %s variable '%s' is read-only. Use SET %s to assign the value + public final static int ER_WARN_ENGINE_TRANSACTION_ROLLBACK = 1622; //SQLSTATE: HY000 Message: Storage engine %s does not support rollback for this statement. Transaction rolled back and must be restarted + @Deprecated + public final static int ER_SLAVE_HEARTBEAT_FAILURE = 1623; + public final static int ER_REPLICA_HEARTBEAT_FAILURE = 1623; //SQLSTATE: HY000 Message: Unexpected source's heartbeat data: %s + @Deprecated + public final static int ER_SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE = 1624; + public final static int ER_REPLICA_HEARTBEAT_VALUE_OUT_OF_RANGE = 1624; //SQLSTATE: HY000 Message: The requested value for the heartbeat period is either negative or exceeds the maximum allowed (%s seconds). + public final static int ER_NDB_REPLICATION_SCHEMA_ERROR = 1625; //SQLSTATE: HY000 Message: Bad schema for mysql.ndb_replication table. Message: %s + public final static int ER_CONFLICT_FN_PARSE_ERROR = 1626; //SQLSTATE: HY000 Message: Error in parsing conflict function. Message: %s + public final static int ER_EXCEPTIONS_WRITE_ERROR = 1627; //SQLSTATE: HY000 Message: Write to exceptions table failed. Message: %s" + public final static int ER_TOO_LONG_TABLE_COMMENT = 1628; //SQLSTATE: HY000 Message: Comment for table '%s' is too long (max = %lu) + public final static int ER_TOO_LONG_FIELD_COMMENT = 1629; //SQLSTATE: HY000 Message: Comment for field '%s' is too long (max = %lu) + public final static int ER_FUNC_INEXISTENT_NAME_COLLISION = 1630; //SQLSTATE: 42000 Message: FUNCTION %s does not exist. Check the 'Function Name Parsing and Resolution' section in the Reference Manual + public final static int ER_DATABASE_NAME = 1631; //SQLSTATE: HY000 Message: Database + public final static int ER_TABLE_NAME = 1632; //SQLSTATE: HY000 Message: Table + public final static int ER_PARTITION_NAME = 1633; //SQLSTATE: HY000 Message: Partition + public final static int ER_SUBPARTITION_NAME = 1634; //SQLSTATE: HY000 Message: Subpartition + public final static int ER_TEMPORARY_NAME = 1635; //SQLSTATE: HY000 Message: Temporary + public final static int ER_RENAMED_NAME = 1636; //SQLSTATE: HY000 Message: Renamed + public final static int ER_TOO_MANY_CONCURRENT_TRXS = 1637; //SQLSTATE: HY000 Message: Too many active concurrent transactions + public final static int WARN_NON_ASCII_SEPARATOR_NOT_IMPLEMENTED = 1638; //SQLSTATE: HY000 Message: Non-ASCII separator arguments are not fully supported + public final static int ER_DEBUG_SYNC_TIMEOUT = 1639; //SQLSTATE: HY000 Message: debug sync point wait timed out + public final static int ER_DEBUG_SYNC_HIT_LIMIT = 1640; //SQLSTATE: HY000 Message: debug sync point hit limit reached + public final static int ER_DUP_SIGNAL_SET = 1641; //SQLSTATE: 42000 Message: Duplicate condition information item '%s' + public final static int ER_SIGNAL_WARN = 1642; //SQLSTATE: 01000 Message: Unhandled user-defined warning condition + public final static int ER_SIGNAL_NOT_FOUND = 1643; //SQLSTATE: 02000 Message: Unhandled user-defined not found condition + public final static int ER_SIGNAL_EXCEPTION = 1644; //SQLSTATE: HY000 Message: Unhandled user-defined exception condition + public final static int ER_RESIGNAL_WITHOUT_ACTIVE_HANDLER = 1645; //SQLSTATE: 0K000 Message: RESIGNAL when handler not active + public final static int ER_SIGNAL_BAD_CONDITION_TYPE = 1646; //SQLSTATE: HY000 Message: SIGNAL/RESIGNAL can only use a CONDITION defined with; //SQLSTATE + public final static int WARN_COND_ITEM_TRUNCATED = 1647; //SQLSTATE: HY000 Message: Data truncated for condition item '%s' + public final static int ER_COND_ITEM_TOO_LONG = 1648; //SQLSTATE: HY000 Message: Data too long for condition item '%s' + public final static int ER_UNKNOWN_LOCALE = 1649; //SQLSTATE: HY000 Message: Unknown locale: '%s' + @Deprecated + public final static int ER_SLAVE_IGNORE_SERVER_IDS = 1650; + public final static int ER_REPLICA_IGNORE_SERVER_IDS = 1650; //SQLSTATE: HY000 Message: The requested server id %d clashes with the replica startup option --replicate-same-server-id + public final static int ER_QUERY_CACHE_DISABLED = 1651; //SQLSTATE: HY000 Message: Query cache is disabled; restart the server with query_cache_type=1 to enable it + public final static int ER_SAME_NAME_PARTITION_FIELD = 1652; //SQLSTATE: HY000 Message: Duplicate partition field name '%s' + public final static int ER_PARTITION_COLUMN_LIST_ERROR = 1653; //SQLSTATE: HY000 Message: Inconsistency in usage of column lists for partitioning + public final static int ER_WRONG_TYPE_COLUMN_VALUE_ERROR = 1654; //SQLSTATE: HY000 Message: Partition column values of incorrect type + public final static int ER_TOO_MANY_PARTITION_FUNC_FIELDS_ERROR = 1655; //SQLSTATE: HY000 Message: Too many fields in '%s' + public final static int ER_MAXVALUE_IN_VALUES_IN = 1656; //SQLSTATE: HY000 Message: Cannot use MAXVALUE as value in VALUES IN + public final static int ER_TOO_MANY_VALUES_ERROR = 1657; //SQLSTATE: HY000 Message: Cannot have more than one value for this type of %s partitioning + public final static int ER_ROW_SINGLE_PARTITION_FIELD_ERROR = 1658; //SQLSTATE: HY000 Message: Row expressions in VALUES IN only allowed for multi-field column partitioning + public final static int ER_FIELD_TYPE_NOT_ALLOWED_AS_PARTITION_FIELD = 1659; //SQLSTATE: HY000 Message: Field '%s' is of a not allowed type for this type of partitioning + public final static int ER_PARTITION_FIELDS_TOO_LONG = 1660; //SQLSTATE: HY000 Message: The total length of the partitioning fields is too large + public final static int ER_BINLOG_ROW_ENGINE_AND_STMT_ENGINE = 1661; //SQLSTATE: HY000 Message: Cannot execute statement: impossible to write to binary log since both row-incapable engines and statement-incapable engines are involved. + public final static int ER_BINLOG_ROW_MODE_AND_STMT_ENGINE = 1662; //SQLSTATE: HY000 Message: Cannot execute statement: impossible to write to binary log since BINLOG_FORMAT = ROW and at least one table uses a storage engine limited to statement-based logging. + public final static int ER_BINLOG_UNSAFE_AND_STMT_ENGINE = 1663; //SQLSTATE: HY000 Message: Cannot execute statement: impossible to write to binary log since statement is unsafe, storage engine is limited to statement-based logging, and BINLOG_FORMAT = MIXED. %s + public final static int ER_BINLOG_ROW_INJECTION_AND_STMT_ENGINE = 1664; //SQLSTATE: HY000 Message: Cannot execute statement: impossible to write to binary log since statement is in row format and at least one table uses a storage engine limited to statement-based logging. + public final static int ER_BINLOG_STMT_MODE_AND_ROW_ENGINE = 1665; //SQLSTATE: HY000 Message: Cannot execute statement: impossible to write to binary log since BINLOG_FORMAT = STATEMENT and at least one table uses a storage engine limited to row-based logging.%s + public final static int ER_BINLOG_ROW_INJECTION_AND_STMT_MODE = 1666; //SQLSTATE: HY000 Message: Cannot execute statement: impossible to write to binary log since statement is in row format and BINLOG_FORMAT = STATEMENT. + public final static int ER_BINLOG_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE = 1667; //SQLSTATE: HY000 Message: Cannot execute statement: impossible to write to binary log since more than one engine is involved and at least one engine is self-logging. + public final static int ER_BINLOG_UNSAFE_LIMIT = 1668; //SQLSTATE: HY000 Message: The statement is unsafe because it uses a LIMIT clause. This is unsafe because the set of rows included cannot be predicted. + public final static int ER_BINLOG_UNSAFE_INSERT_DELAYED = 1669; //SQLSTATE: HY000 Message: The statement is unsafe because it uses INSERT DELAYED. This is unsafe because the times when rows are inserted cannot be predicted. + public final static int ER_BINLOG_UNSAFE_SYSTEM_TABLE = 1670; //SQLSTATE: HY000 Message: The statement is unsafe because it uses the general log, slow query log, or performance_schema table(s). This is unsafe because system tables may differ on replicas. + public final static int ER_BINLOG_UNSAFE_AUTOINC_COLUMNS = 1671; //SQLSTATE: HY000 Message: Statement is unsafe because it invokes a trigger or a stored function that inserts into an AUTO_INCREMENT column. Inserted values cannot be logged correctly. + public final static int ER_BINLOG_UNSAFE_UDF = 1672; //SQLSTATE: HY000 Message: Statement is unsafe because it uses a UDF which may not return the same value on the replica. + public final static int ER_BINLOG_UNSAFE_SYSTEM_VARIABLE = 1673; //SQLSTATE: HY000 Message: Statement is unsafe because it uses a system variable that may have a different value on the replica. + public final static int ER_BINLOG_UNSAFE_SYSTEM_FUNCTION = 1674; //SQLSTATE: HY000 Message: Statement is unsafe because it uses a system function that may return a different value on the replica. + public final static int ER_BINLOG_UNSAFE_NONTRANS_AFTER_TRANS = 1675; //SQLSTATE: HY000 Message: Statement is unsafe because it accesses a non-transactional table after accessing a transactional table within the same transaction. + public final static int ER_MESSAGE_AND_STATEMENT = 1676; //SQLSTATE: HY000 Message: %s Statement: %s + @Deprecated + public final static int ER_SLAVE_CONVERSION_FAILED = 1677; + public final static int ER_REPLICA_CONVERSION_FAILED = 1677; //SQLSTATE: HY000 Message: Column %d of table '%s.%s' cannot be converted from type '%s' to type '%s' + @Deprecated + public final static int ER_SLAVE_CANT_CREATE_CONVERSION = 1678; + public final static int ER_REPLICA_CANT_CREATE_CONVERSION = 1678; //SQLSTATE: HY000 Message: Can't create conversion table for table '%s.%s' + public final static int ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_FORMAT = 1679; //SQLSTATE: HY000 Message: Cannot modify @@session.binlog_format inside a transaction + public final static int ER_PATH_LENGTH = 1680; //SQLSTATE: HY000 Message: The path specified for %s is too long. + public final static int ER_WARN_DEPRECATED_SYNTAX_NO_REPLACEMENT = 1681; //SQLSTATE: HY000 Message: The syntax '%s' is deprecated and will be removed in MySQL %s. + public final static int ER_WRONG_NATIVE_TABLE_STRUCTURE = 1682; //SQLSTATE: HY000 Message: Native table '%s'.'%s' has the wrong structure + public final static int ER_WRONG_PERFSCHEMA_USAGE = 1683; //SQLSTATE: HY000 Message: Invalid performance_schema usage. + public final static int ER_WARN_I_S_SKIPPED_TABLE = 1684; //SQLSTATE: HY000 Message: Table '%s'.'%s' was skipped since its definition is being modified by concurrent DDL statement + public final static int ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_DIRECT = 1685; //SQLSTATE: HY000 Message: Cannot modify @@session.binlog_direct_non_transactional_updates inside a transaction + public final static int ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_DIRECT = 1686; //SQLSTATE: HY000 Message: Cannot change the binlog direct flag inside a stored function or trigger + public final static int ER_SPATIAL_MUST_HAVE_GEOM_COL = 1687; //SQLSTATE: 42000 Message: A SPATIAL index may only contain a geometrical type column + public final static int ER_TOO_LONG_INDEX_COMMENT = 1688; //SQLSTATE: HY000 Message: Comment for index '%s' is too long (max = %lu) + public final static int ER_LOCK_ABORTED = 1689; //SQLSTATE: HY000 Message: Wait on a lock was aborted due to a pending exclusive lock + public final static int ER_DATA_OUT_OF_RANGE = 1690; //SQLSTATE: 22003 Message: %s value is out of range in '%s' + public final static int ER_WRONG_SPVAR_TYPE_IN_LIMIT = 1691; //SQLSTATE: HY000 Message: A variable of a non-integer type in LIMIT clause + public final static int ER_BINLOG_UNSAFE_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE = 1692; //SQLSTATE: HY000 Message: Mixing self-logging and non-self-logging engines in a statement is unsafe. + public final static int ER_BINLOG_UNSAFE_MIXED_STATEMENT = 1693; //SQLSTATE: HY000 Message: Statement accesses nontransactional table as well as transactional or temporary table, and writes to any of them. + public final static int ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_SQL_LOG_BIN = 1694; //SQLSTATE: HY000 Message: Cannot modify @@session.sql_log_bin inside a transaction + public final static int ER_STORED_FUNCTION_PREVENTS_SWITCH_SQL_LOG_BIN = 1695; //SQLSTATE: HY000 Message: Cannot change the sql_log_bin inside a stored function or trigger + public final static int ER_FAILED_READ_FROM_PAR_FILE = 1696; //SQLSTATE: HY000 Message: Failed to read from the .par file + public final static int ER_VALUES_IS_NOT_INT_TYPE_ERROR = 1697; //SQLSTATE: HY000 Message: VALUES value for partition '%s' must have type INT + public final static int ER_ACCESS_DENIED_NO_PASSWORD_ERROR = 1698; //SQLSTATE: 28000 Message: Access denied for user '%s'@'%s' + public final static int ER_SET_PASSWORD_AUTH_PLUGIN = 1699; //SQLSTATE: HY000 Message: SET PASSWORD has no significance for users authenticating via plugins + public final static int ER_GRANT_PLUGIN_USER_EXISTS = 1700; //SQLSTATE: HY000 Message: GRANT with IDENTIFIED WITH is illegal because the user %-.*s already exists + public final static int ER_TRUNCATE_ILLEGAL_FK = 1701; //SQLSTATE: 42000 Message: Cannot truncate a table referenced in a foreign key constraint (%s) + public final static int ER_PLUGIN_IS_PERMANENT = 1702; //SQLSTATE: HY000 Message: Plugin '%s' is force_plus_permanent and can not be unloaded + @Deprecated + public final static int ER_SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE_MIN = 1703; + public final static int ER_REPLICA_HEARTBEAT_VALUE_OUT_OF_RANGE_MIN = 1703; //SQLSTATE: HY000 Message: The requested value for the heartbeat period is less than 1 millisecond. The value is reset to 0, meaning that heartbeating will effectively be disabled. + @Deprecated + public final static int ER_SLAVE_HEARTBEAT_VALUE_OUT_OF_RANGE_MAX = 1704; + public final static int ER_REPLICA_HEARTBEAT_VALUE_OUT_OF_RANGE_MAX = 1704; //SQLSTATE: HY000 Message: The requested value for the heartbeat period exceeds the value of `replica_net_timeout' seconds. A sensible value for the period should be less than the timeout. + public final static int ER_STMT_CACHE_FULL = 1705; //SQLSTATE: HY000 Message: Multi-row statements required more than 'max_binlog_stmt_cache_size' bytes of storage; increase this mysqld variable and try again + + public final static int ER_MULTI_UPDATE_KEY_CONFLICT = 1706; //SQLSTATE: HY000 Message: Primary key/partition key update is not allowed since the table is updated both as '%s' and '%s'. + public final static int ER_TABLE_NEEDS_REBUILD = 1707; //SQLSTATE: HY000 Message: Table rebuild required. Please do "ALTER TABLE `%s` FORCE" or dump/reload to fix it! + public final static int WARN_OPTION_BELOW_LIMIT = 1708; //SQLSTATE: HY000 Message: The value of '%s' should be no less than the value of '%s' + public final static int ER_INDEX_COLUMN_TOO_LONG = 1709; //SQLSTATE: HY000 Message: Index column size too large. The maximum column size is %lu bytes. + public final static int ER_ERROR_IN_TRIGGER_BODY = 1710; //SQLSTATE: HY000 Message: Trigger '%s' has an error in its body: '%s' + public final static int ER_ERROR_IN_UNKNOWN_TRIGGER_BODY = 1711; //SQLSTATE: HY000 Message: Unknown trigger has an error in its body: '%s' + public final static int ER_INDEX_CORRUPT = 1712; //SQLSTATE: HY000 Message: Index %s is corrupted + public final static int ER_UNDO_RECORD_TOO_BIG = 1713; //SQLSTATE: HY000 Message: Undo log record is too big. + public final static int ER_BINLOG_UNSAFE_INSERT_IGNORE_SELECT = 1714; //SQLSTATE: HY000 Message: INSERT IGNORE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are ignored. This order cannot be predicted and may differ on source and the replica. + public final static int ER_BINLOG_UNSAFE_INSERT_SELECT_UPDATE = 1715; //SQLSTATE: HY000 Message: INSERT... SELECT... ON DUPLICATE KEY UPDATE is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are updated. This order cannot be predicted and may differ on source and the replica. + public final static int ER_BINLOG_UNSAFE_REPLACE_SELECT = 1716; //SQLSTATE: HY000 Message: REPLACE... SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on source and the replica. + public final static int ER_BINLOG_UNSAFE_CREATE_IGNORE_SELECT = 1717; //SQLSTATE: HY000 Message: CREATE... IGNORE SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are ignored. This order cannot be predicted and may differ on source and the replica. + public final static int ER_BINLOG_UNSAFE_CREATE_REPLACE_SELECT = 1718; //SQLSTATE: HY000 Message: CREATE... REPLACE SELECT is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are replaced. This order cannot be predicted and may differ on source and the replica. + public final static int ER_BINLOG_UNSAFE_UPDATE_IGNORE = 1719; //SQLSTATE: HY000 Message: UPDATE IGNORE is unsafe because the order in which rows are updated determines which (if any) rows are ignored. This order cannot be predicted and may differ on source and the replica. + public final static int ER_PLUGIN_NO_UNINSTALL = 1720; //SQLSTATE: HY000 Message: Plugin '%s' is marked as not dynamically uninstallable. You have to stop the server to uninstall it. + public final static int ER_PLUGIN_NO_INSTALL = 1721; //SQLSTATE: HY000 Message: Plugin '%s' is marked as not dynamically installable. You have to stop the server to install it. + public final static int ER_BINLOG_UNSAFE_WRITE_AUTOINC_SELECT = 1722; //SQLSTATE: HY000 Message: Statements writing to a table with an auto-increment column after selecting from another table are unsafe because the order in which rows are retrieved determines what (if any) rows will be written. This order cannot be predicted and may differ on source and the replica. + public final static int ER_BINLOG_UNSAFE_CREATE_SELECT_AUTOINC = 1723; //SQLSTATE: HY000 Message: CREATE TABLE... SELECT... on a table with an auto-increment column is unsafe because the order in which rows are retrieved by the SELECT determines which (if any) rows are inserted. This order cannot be predicted and may differ on source and the replica. + public final static int ER_BINLOG_UNSAFE_INSERT_TWO_KEYS = 1724; //SQLSTATE: HY000 Message: INSERT... ON DUPLICATE KEY UPDATE on a table with more than one UNIQUE KEY is unsafe + public final static int ER_TABLE_IN_FK_CHECK = 1725; //SQLSTATE: HY000 Message: Table is being used in foreign key check. + public final static int ER_UNSUPPORTED_ENGINE = 1726; //SQLSTATE: HY000 Message: Storage engine '%s' does not support system tables. [%s.%s] + public final static int ER_BINLOG_UNSAFE_AUTOINC_NOT_FIRST = 1727; //SQLSTATE: HY000 Message: INSERT into autoincrement field which is not the first part in the composed primary key is unsafe. + public final static int ER_CANNOT_LOAD_FROM_TABLE_V2 = 1728; //SQLSTATE: HY000 Message: Cannot load from %s.%s. The table is probably corrupted + @Deprecated + public final static int ER_MASTER_DELAY_VALUE_OUT_OF_RANGE = 1729; + public final static int ER_SOURCE_DELAY_VALUE_OUT_OF_RANGE = 1729; //SQLSTATE: HY000 Message: The requested value %u for the source delay exceeds the maximum %u + public final static int ER_ONLY_FD_AND_RBR_EVENTS_ALLOWED_IN_BINLOG_STATEMENT = 1730; //SQLSTATE: HY000 Message: Only Format_description_log_event and row events are allowed in BINLOG statements (but %s was provided) + public final static int ER_PARTITION_EXCHANGE_DIFFERENT_OPTION = 1731; //SQLSTATE: HY000 Message: Non matching attribute '%s' between partition and table + public final static int ER_PARTITION_EXCHANGE_PART_TABLE = 1732; //SQLSTATE: HY000 Message: Table to exchange with partition is partitioned: '%s' + public final static int ER_PARTITION_EXCHANGE_TEMP_TABLE = 1733; //SQLSTATE: HY000 Message: Table to exchange with partition is temporary: '%s' + public final static int ER_PARTITION_INSTEAD_OF_SUBPARTITION = 1734; //SQLSTATE: HY000 Message: Subpartitioned table, use subpartition instead of partition + public final static int ER_UNKNOWN_PARTITION = 1735; //SQLSTATE: HY000 Message: Unknown partition '%s' in table '%s' + public final static int ER_TABLES_DIFFERENT_METADATA = 1736; //SQLSTATE: HY000 Message: Tables have different definitions + public final static int ER_ROW_DOES_NOT_MATCH_PARTITION = 1737; //SQLSTATE: HY000 Message: Found a row that does not match the partition + public final static int ER_BINLOG_CACHE_SIZE_GREATER_THAN_MAX = 1738; //SQLSTATE: HY000 Message: Option binlog_cache_size (%lu) is greater than max_binlog_cache_size (%lu); setting binlog_cache_size equal to max_binlog_cache_size. + public final static int ER_WARN_INDEX_NOT_APPLICABLE = 1739; //SQLSTATE: HY000 Message: Cannot use %s access on index '%s' due to type or collation conversion on field '%s' + public final static int ER_PARTITION_EXCHANGE_FOREIGN_KEY = 1740; //SQLSTATE: HY000 Message: Table to exchange with partition has foreign key references: '%s' + public final static int ER_NO_SUCH_KEY_VALUE = 1741; //SQLSTATE: HY000 Message: Key value '%s' was not found in table '%s.%s' + public final static int ER_RPL_INFO_DATA_TOO_LONG = 1742; //SQLSTATE: HY000 Message: Data for column '%s' too long + public final static int ER_NETWORK_READ_EVENT_CHECKSUM_FAILURE = 1743; //SQLSTATE: HY000 Message: Replication event checksum verification failed while reading from network. + public final static int ER_BINLOG_READ_EVENT_CHECKSUM_FAILURE = 1744; //SQLSTATE: HY000 Message: Replication event checksum verification failed while reading from a log file. + public final static int ER_BINLOG_STMT_CACHE_SIZE_GREATER_THAN_MAX = 1745; //SQLSTATE: HY000 Message: Option binlog_stmt_cache_size (%lu) is greater than max_binlog_stmt_cache_size (%lu); setting binlog_stmt_cache_size equal to max_binlog_stmt_cache_size. + public final static int ER_CANT_UPDATE_TABLE_IN_CREATE_TABLE_SELECT = 1746; //SQLSTATE: HY000 Message: Can't update table '%s' while '%s' is being created. + public final static int ER_PARTITION_CLAUSE_ON_NONPARTITIONED = 1747; //SQLSTATE: HY000 Message: PARTITION () clause on non partitioned table + public final static int ER_ROW_DOES_NOT_MATCH_GIVEN_PARTITION_SET = 1748; //SQLSTATE: HY000 Message: Found a row not matching the given partition set + public final static int ER_NO_SUCH_PARTITION__UNUSED = 1749; //SQLSTATE: HY000 Message: partition '%s' doesn't exist + public final static int ER_CHANGE_RPL_INFO_REPOSITORY_FAILURE = 1750; //SQLSTATE: HY000 Message: Failure while changing the type of replication repository: %s. + public final static int ER_WARNING_NOT_COMPLETE_ROLLBACK_WITH_CREATED_TEMP_TABLE = 1751; //SQLSTATE: HY000 Message: The creation of some temporary tables could not be rolled back. + public final static int ER_WARNING_NOT_COMPLETE_ROLLBACK_WITH_DROPPED_TEMP_TABLE = 1752; //SQLSTATE: HY000 Message: Some temporary tables were dropped, but these operations could not be rolled back. + public final static int ER_MTS_FEATURE_IS_NOT_SUPPORTED = 1753; //SQLSTATE: HY000 Message: %s is not supported in multi-threaded replica mode. %s + public final static int ER_MTS_UPDATED_DBS_GREATER_MAX = 1754; //SQLSTATE: HY000 Message: The number of modified databases exceeds the maximum %d; the database names will not be included in the replication event metadata. + public final static int ER_MTS_CANT_PARALLEL = 1755; //SQLSTATE: HY000 Message: Cannot execute the current event group in the parallel mode. Encountered event %s, relay-log name %s, position %s which prevents execution of this event group in parallel mode. Reason: %s. + public final static int ER_MTS_INCONSISTENT_DATA = 1756; //SQLSTATE: HY000 Message: %s + public final static int ER_FULLTEXT_NOT_SUPPORTED_WITH_PARTITIONING = 1757; //SQLSTATE: HY000 Message: FULLTEXT index is not supported for partitioned tables. + public final static int ER_DA_INVALID_CONDITION_NUMBER = 1758; //SQLSTATE: 35000 Message: Invalid condition number + public final static int ER_INSECURE_PLAIN_TEXT = 1759; //SQLSTATE: HY000 Message: Sending passwords in plain text without SSL/TLS is extremely insecure. + @Deprecated + public final static int ER_INSECURE_CHANGE_MASTER = 1760; + public final static int ER_INSECURE_CHANGE_SOURCE = 1760; //SQLSTATE: HY000 Message: Storing MySQL user name or password information in the source.info repository is not secure and is therefore not recommended. Please see the MySQL Manual for more about this issue and possible alternatives. + public final static int ER_FOREIGN_DUPLICATE_KEY_WITH_CHILD_INFO = 1761; //SQLSTATE: 23000 Message: Foreign key constraint for table '%s', record '%s' would lead to a duplicate entry in table '%s', key '%s' + public final static int ER_FOREIGN_DUPLICATE_KEY_WITHOUT_CHILD_INFO = 1762; //SQLSTATE: 23000 Message: Foreign key constraint for table '%s', record '%s' would lead to a duplicate entry in a child table + @Deprecated + public final static int ER_SQLTHREAD_WITH_SECURE_SLAVE = 1763; + public final static int ER_SQLTHREAD_WITH_SECURE_REPLICA = 1763; //SQLSTATE: HY000 Message: Setting authentication options is not possible when only the Replica SQL Thread is being started. + public final static int ER_TABLE_HAS_NO_FT = 1764; //SQLSTATE: HY000 Message: The table does not have FULLTEXT index to support this query + public final static int ER_VARIABLE_NOT_SETTABLE_IN_SF_OR_TRIGGER = 1765; //SQLSTATE: HY000 Message: The system variable %s cannot be set in stored functions or triggers. + public final static int ER_VARIABLE_NOT_SETTABLE_IN_TRANSACTION = 1766; //SQLSTATE: HY000 Message: The system variable %s cannot be set when there is an ongoing transaction. + public final static int ER_GTID_NEXT_IS_NOT_IN_GTID_NEXT_LIST = 1767; //SQLSTATE: HY000 Message: The system variable @@SESSION.GTID_NEXT has the value %s, which is not listed in @@SESSION.GTID_NEXT_LIST. + public final static int ER_CANT_CHANGE_GTID_NEXT_IN_TRANSACTION_WHEN_GTID_NEXT_LIST_IS_NULL = 1768; //SQLSTATE: HY000 Message: When @@SESSION.GTID_NEXT_LIST == NULL, the system variable @@SESSION.GTID_NEXT cannot change inside a transaction. + public final static int ER_SET_STATEMENT_CANNOT_INVOKE_FUNCTION = 1769; //SQLSTATE: HY000 Message: The statement 'SET %s' cannot invoke a stored function. + public final static int ER_GTID_NEXT_CANT_BE_AUTOMATIC_IF_GTID_NEXT_LIST_IS_NON_NULL = 1770; //SQLSTATE: HY000 Message: The system variable @@SESSION.GTID_NEXT cannot be 'AUTOMATIC' when @@SESSION.GTID_NEXT_LIST is non-NULL. + public final static int ER_SKIPPING_LOGGED_TRANSACTION = 1771; //SQLSTATE: HY000 Message: Skipping transaction %s because it has already been executed and logged. + public final static int ER_MALFORMED_GTID_SET_SPECIFICATION = 1772; //SQLSTATE: HY000 Message: Malformed GTID set specification '%s'. + public final static int ER_MALFORMED_GTID_SET_ENCODING = 1773; //SQLSTATE: HY000 Message: Malformed GTID set encoding. + public final static int ER_MALFORMED_GTID_SPECIFICATION = 1774; //SQLSTATE: HY000 Message: Malformed GTID specification '%s'. + public final static int ER_GNO_EXHAUSTED = 1775; //SQLSTATE: HY000 Message: Impossible to generate Global Transaction Identifier: the integer component reached the maximal value. Restart the server with a new server_uuid. + @Deprecated + public final static int ER_BAD_SLAVE_AUTO_POSITION = 1776; + public final static int ER_BAD_REPLICA_AUTO_POSITION = 1776; //SQLSTATE: HY000 Message: Parameters SOURCE_LOG_FILE, SOURCE_LOG_POS, RELAY_LOG_FILE and RELAY_LOG_POS cannot be set when SOURCE_AUTO_POSITION is active. + public final static int ER_AUTO_POSITION_REQUIRES_GTID_MODE_ON = 1777; //SQLSTATE: HY000 Message: CHANGE SOURCE TO SOURCE_AUTO_POSITION = 1 can only be executed when GTID_MODE = ON. + public final static int ER_CANT_DO_IMPLICIT_COMMIT_IN_TRX_WHEN_GTID_NEXT_IS_SET = 1778; //SQLSTATE: HY000 Message: Cannot execute statements with implicit commit inside a transaction when GTID_NEXT != AUTOMATIC or GTID_NEXT_LIST != NULL. + public final static int ER_GTID_MODE_2_OR_3_REQUIRES_ENFORCE_GTID_CONSISTENCY_ON = 1779; //SQLSTATE: HY000 Message: GTID_MODE = ON or GTID_MODE = UPGRADE_STEP_2 requires ENFORCE_GTID_CONSISTENCY = 1. + public final static int ER_GTID_MODE_REQUIRES_BINLOG = 1780; //SQLSTATE: HY000 Message: GTID_MODE = ON or UPGRADE_STEP_1 or UPGRADE_STEP_2 requires --log-bin and --log-replica-updates. + public final static int ER_CANT_SET_GTID_NEXT_TO_GTID_WHEN_GTID_MODE_IS_OFF = 1781; //SQLSTATE: HY000 Message: GTID_NEXT cannot be set to UUID:NUMBER when GTID_MODE = OFF. + public final static int ER_CANT_SET_GTID_NEXT_TO_ANONYMOUS_WHEN_GTID_MODE_IS_ON = 1782; //SQLSTATE: HY000 Message: GTID_NEXT cannot be set to ANONYMOUS when GTID_MODE = ON. + public final static int ER_CANT_SET_GTID_NEXT_LIST_TO_NON_NULL_WHEN_GTID_MODE_IS_OFF = 1783; //SQLSTATE: HY000 Message: GTID_NEXT_LIST cannot be set to a non-NULL value when GTID_MODE = OFF. + public final static int ER_FOUND_GTID_EVENT_WHEN_GTID_MODE_IS_OFF = 1784; //SQLSTATE: HY000 Message: Found a Gtid_log_event or Previous_gtids_log_event when GTID_MODE = OFF. + public final static int ER_GTID_UNSAFE_NON_TRANSACTIONAL_TABLE = 1785; //SQLSTATE: HY000 Message: When ENFORCE_GTID_CONSISTENCY = 1, updates to non-transactional tables can only be done in either autocommitted statements or single-statement transactions, and never in the same statement as updates to transactional tables. + public final static int ER_GTID_UNSAFE_CREATE_SELECT = 1786; //SQLSTATE: HY000 Message: CREATE TABLE ... SELECT is forbidden when ENFORCE_GTID_CONSISTENCY = 1. + public final static int ER_GTID_UNSAFE_CREATE_DROP_TEMPORARY_TABLE_IN_TRANSACTION = 1787; //SQLSTATE: HY000 Message: When ENFORCE_GTID_CONSISTENCY = 1, the statements CREATE TEMPORARY TABLE and DROP TEMPORARY TABLE can be executed in a non-transactional context only, and require that AUTOCOMMIT = 1. + public final static int ER_GTID_MODE_CAN_ONLY_CHANGE_ONE_STEP_AT_A_TIME = 1788; //SQLSTATE: HY000 Message: The value of GTID_MODE can only change one step at a time: OFF <-> UPGRADE_STEP_1 <-> UPGRADE_STEP_2 <-> ON. Also note that this value must be stepped up or down simultaneously on all servers; see the Manual for instructions. + @Deprecated + public final static int ER_MASTER_HAS_PURGED_REQUIRED_GTIDS = 1789; + public final static int ER_SOURCE_HAS_PURGED_REQUIRED_GTIDS = 1789; //SQLSTATE: HY000 Message: The replica is connecting using CHANGE SOURCE TO SOURCE_AUTO_POSITION = 1, but the source has purged binary logs containing GTIDs that the replica requires. + public final static int ER_CANT_SET_GTID_NEXT_WHEN_OWNING_GTID = 1790; //SQLSTATE: HY000 Message: GTID_NEXT cannot be changed by a client that owns a GTID. The client owns %s. Ownership is released on COMMIT or ROLLBACK. + public final static int ER_UNKNOWN_EXPLAIN_FORMAT = 1791; //SQLSTATE: HY000 Message: Unknown EXPLAIN format name: '%s' + public final static int ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION = 1792; //SQLSTATE: 25006 Message: Cannot execute statement in a READ ONLY transaction. + public final static int ER_TOO_LONG_TABLE_PARTITION_COMMENT = 1793; //SQLSTATE: HY000 Message: Comment for table partition '%s' is too long (max = %lu) + @Deprecated + public final static int ER_SLAVE_CONFIGURATION = 1794; + public final static int ER_REPLICA_CONFIGURATION = 1794; //SQLSTATE: HY000 Message: Replica is not configured or failed to initialize properly. You must at least set --server-id to enable either a source or a replica. Additional error messages can be found in the MySQL error log. + public final static int ER_INNODB_FT_LIMIT = 1795; //SQLSTATE: HY000 Message: InnoDB presently supports one FULLTEXT index creation at a time + public final static int ER_INNODB_NO_FT_TEMP_TABLE = 1796; //SQLSTATE: HY000 Message: Cannot create FULLTEXT index on temporary InnoDB table + public final static int ER_INNODB_FT_WRONG_DOCID_COLUMN = 1797; //SQLSTATE: HY000 Message: Column '%s' is of wrong type for an InnoDB FULLTEXT index + public final static int ER_INNODB_FT_WRONG_DOCID_INDEX = 1798; //SQLSTATE: HY000 Message: Index '%s' is of wrong type for an InnoDB FULLTEXT index + public final static int ER_INNODB_ONLINE_LOG_TOO_BIG = 1799; //SQLSTATE: HY000 Message: Creating index '%s' required more than 'innodb_online_alter_log_max_size' bytes of modification log. Please try again. + public final static int ER_UNKNOWN_ALTER_ALGORITHM = 1800; //SQLSTATE: HY000 Message: Unknown ALGORITHM '%s' + public final static int ER_UNKNOWN_ALTER_LOCK = 1801; //SQLSTATE: HY000 Message: Unknown LOCK type '%s' + @Deprecated + public final static int ER_MTS_CHANGE_MASTER_CANT_RUN_WITH_GAPS = 1802; + public final static int ER_MTS_CHANGE_SOURCE_CANT_RUN_WITH_GAPS = 1802; //SQLSTATE: HY000 Message: CHANGE SOURCE cannot be executed when the replica was stopped with an error or killed in MTS mode. Consider using RESET REPLICA or START REPLICA UNTIL. + public final static int ER_MTS_RECOVERY_FAILURE = 1803; //SQLSTATE: HY000 Message: Cannot recover after REPLICA errored out in parallel execution mode. Additional error messages can be found in the MySQL error log. + public final static int ER_MTS_RESET_WORKERS = 1804; //SQLSTATE: HY000 Message: Cannot clean up worker info tables. Additional error messages can be found in the MySQL error log. + public final static int ER_COL_COUNT_DOESNT_MATCH_CORRUPTED_V2 = 1805; //SQLSTATE: HY000 Message: Column count of %s.%s is wrong. Expected %d, found %d. The table is probably corrupted + @Deprecated + public final static int ER_SLAVE_SILENT_RETRY_TRANSACTION = 1806; + public final static int ER_REPLICA_SILENT_RETRY_TRANSACTION = 1806; //SQLSTATE: HY000 Message: Replica must silently retry current transaction + public final static int ER_DISCARD_FK_CHECKS_RUNNING = 1807; //SQLSTATE: HY000 Message: There is a foreign key check running on table '%s'. Cannot discard the table. + public final static int ER_TABLE_SCHEMA_MISMATCH = 1808; //SQLSTATE: HY000 Message: Schema mismatch (%s) + public final static int ER_TABLE_IN_SYSTEM_TABLESPACE = 1809; //SQLSTATE: HY000 Message: Table '%s' in system tablespace + public final static int ER_IO_READ_ERROR = 1810; //SQLSTATE: HY000 Message: IO Read error: (%lu, %s) %s + public final static int ER_IO_WRITE_ERROR = 1811; //SQLSTATE: HY000 Message: IO Write error: (%lu, %s) %s + public final static int ER_TABLESPACE_MISSING = 1812; //SQLSTATE: HY000 Message: Tablespace is missing for table '%s' + public final static int ER_TABLESPACE_EXISTS = 1813; //SQLSTATE: HY000 Message: Tablespace for table '%s' exists. Please DISCARD the tablespace before IMPORT. + public final static int ER_TABLESPACE_DISCARDED = 1814; //SQLSTATE: HY000 Message: Tablespace has been discarded for table '%s' + public final static int ER_INTERNAL_ERROR = 1815; //SQLSTATE: HY000 Message: Internal error: %s + public final static int ER_INNODB_IMPORT_ERROR = 1816; //SQLSTATE: HY000 Message: ALTER TABLE '%s' IMPORT TABLESPACE failed with error %lu : '%s' + public final static int ER_INNODB_INDEX_CORRUPT = 1817; //SQLSTATE: HY000 Message: Index corrupt: %s + public final static int ER_INVALID_YEAR_COLUMN_LENGTH = 1818; //SQLSTATE: HY000 Message: YEAR(%lu) column type is deprecated. Creating YEAR(4) column instead. + public final static int ER_NOT_VALID_PASSWORD = 1819; //SQLSTATE: HY000 Message: Your password does not satisfy the current policy requirements + public final static int ER_MUST_CHANGE_PASSWORD = 1820; //SQLSTATE: HY000 Message: You must SET PASSWORD before executing this statement + public final static int ER_FK_NO_INDEX_CHILD = 1821; //SQLSTATE: HY000 Message: Failed to add the foreign key constaint. Missing index for constraint '%s' in the foreign table '%s' + public final static int ER_FK_NO_INDEX_PARENT = 1822; //SQLSTATE: HY000 Message: Failed to add the foreign key constaint. Missing index for constraint '%s' in the referenced table '%s' + public final static int ER_FK_FAIL_ADD_SYSTEM = 1823; //SQLSTATE: HY000 Message: Failed to add the foreign key constraint '%s' to system tables + public final static int ER_FK_CANNOT_OPEN_PARENT = 1824; //SQLSTATE: HY000 Message: Failed to open the referenced table '%s' + public final static int ER_FK_INCORRECT_OPTION = 1825; //SQLSTATE: HY000 Message: Failed to add the foreign key constraint on table '%s'. Incorrect options in FOREIGN KEY constraint '%s' + public final static int ER_FK_DUP_NAME = 1826; //SQLSTATE: HY000 Message: Duplicate foreign key constraint name '%s' + public final static int ER_PASSWORD_FORMAT = 1827; //SQLSTATE: HY000 Message: The password hash doesn't have the expected format. Check if the correct password algorithm is being used with the PASSWORD() function. + public final static int ER_FK_COLUMN_CANNOT_DROP = 1828; //SQLSTATE: HY000 Message: Cannot drop column '%s': needed in a foreign key constraint '%s' + public final static int ER_FK_COLUMN_CANNOT_DROP_CHILD = 1829; //SQLSTATE: HY000 Message: Cannot drop column '%s': needed in a foreign key constraint '%s' of table '%s' + public final static int ER_FK_COLUMN_NOT_NULL = 1830; //SQLSTATE: HY000 Message: Column '%s' cannot be NOT NULL: needed in a foreign key constraint '%s' SET NULL + public final static int ER_DUP_INDEX = 1831; //SQLSTATE: HY000 Message: Duplicate index '%s' defined on the table '%s.%s'. This is deprecated and will be disallowed in a future release. + public final static int ER_FK_COLUMN_CANNOT_CHANGE = 1832; //SQLSTATE: HY000 Message: Cannot change column '%s': used in a foreign key constraint '%s' + public final static int ER_FK_COLUMN_CANNOT_CHANGE_CHILD = 1833; //SQLSTATE: HY000 Message: Cannot change column '%s': used in a foreign key constraint '%s' of table '%s' + public final static int ER_FK_CANNOT_DELETE_PARENT = 1834; //SQLSTATE: HY000 Message: Cannot delete rows from table which is parent in a foreign key constraint '%s' of table '%s' + public final static int ER_MALFORMED_PACKET = 1835; //SQLSTATE: HY000 Message: Malformed communication packet. + public final static int ER_READ_ONLY_MODE = 1836; //SQLSTATE: HY000 Message: Running in read-only mode + public final static int ER_GTID_NEXT_TYPE_UNDEFINED_GROUP = 1837; //SQLSTATE: HY000 Message: When GTID_NEXT is set to a GTID, you must explicitly set it again after a COMMIT or ROLLBACK. If you see this error message in the replica SQL thread, it means that a table in the current transaction is transactional on the source and non-transactional on the replica. In a client connection, it means that you executed SET GTID_NEXT before a transaction and forgot to set GTID_NEXT to a different identifier or to 'AUTOMATIC' after COMMIT or ROLLBACK. Current GTID_NEXT is '%s'. + public final static int ER_VARIABLE_NOT_SETTABLE_IN_SP = 1838; //SQLSTATE: HY000 Message: The system variable %s cannot be set in stored procedures. + public final static int ER_CANT_SET_GTID_PURGED_WHEN_GTID_MODE_IS_OFF = 1839; //SQLSTATE: HY000 Message: GTID_PURGED can only be set when GTID_MODE = ON. + public final static int ER_CANT_SET_GTID_PURGED_WHEN_GTID_EXECUTED_IS_NOT_EMPTY = 1840; //SQLSTATE: HY000 Message: GTID_PURGED can only be set when GTID_EXECUTED is empty. + public final static int ER_CANT_SET_GTID_PURGED_WHEN_OWNED_GTIDS_IS_NOT_EMPTY = 1841; //SQLSTATE: HY000 Message: GTID_PURGED can only be set when there are no ongoing transactions (not even in other clients). + public final static int ER_GTID_PURGED_WAS_CHANGED = 1842; //SQLSTATE: HY000 Message: GTID_PURGED was changed from '%s' to '%s'. + public final static int ER_GTID_EXECUTED_WAS_CHANGED = 1843; //SQLSTATE: HY000 Message: GTID_EXECUTED was changed from '%s' to '%s'. + public final static int ER_BINLOG_STMT_MODE_AND_NO_REPL_TABLES = 1844; //SQLSTATE: HY000 Message: Cannot execute statement: impossible to write to binary log since BINLOG_FORMAT = STATEMENT, and both replicated and non replicated tables are written to. + public final static int ER_ALTER_OPERATION_NOT_SUPPORTED = 1845; //SQLSTATE: 0A000 Message: %s is not supported for this operation. Try %s. + public final static int ER_ALTER_OPERATION_NOT_SUPPORTED_REASON = 1846; //SQLSTATE: 0A000 Message: %s is not supported. Reason: %s. Try %s. + public final static int ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COPY = 1847; //SQLSTATE: HY000 Message: COPY algorithm requires a lock + public final static int ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_PARTITION = 1848; //SQLSTATE: HY000 Message: Partition specific operations do not yet support LOCK/ALGORITHM + public final static int ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_RENAME = 1849; //SQLSTATE: HY000 Message: Columns participating in a foreign key are renamed + public final static int ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COLUMN_TYPE = 1850; //SQLSTATE: HY000 Message: Cannot change column type INPLACE + public final static int ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_CHECK = 1851; //SQLSTATE: HY000 Message: Adding foreign keys needs foreign_key_checks=OFF + public final static int ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_IGNORE = 1852; //SQLSTATE: HY000 Message: Creating unique indexes with IGNORE requires COPY algorithm to remove duplicate rows + public final static int ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_NOPK = 1853; //SQLSTATE: HY000 Message: Dropping a primary key is not allowed without also adding a new primary key + public final static int ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_AUTOINC = 1854; //SQLSTATE: HY000 Message: Adding an auto-increment column requires a lock + public final static int ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_HIDDEN_FTS = 1855; //SQLSTATE: HY000 Message: Cannot replace hidden FTS_DOC_ID with a user-visible one + public final static int ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_CHANGE_FTS = 1856; //SQLSTATE: HY000 Message: Cannot drop or rename FTS_DOC_ID + public final static int ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FTS = 1857; //SQLSTATE: HY000 Message: Fulltext index creation requires a lock + @Deprecated + public final static int ER_SQL_SLAVE_SKIP_COUNTER_NOT_SETTABLE_IN_GTID_MODE = 1858; + public final static int ER_SQL_REPLICA_SKIP_COUNTER_NOT_SETTABLE_IN_GTID_MODE = 1858; //SQLSTATE: HY000 Message: sql_replica_skip_counter can not be set when the server is running with GTID_MODE = ON. Instead, for each transaction that you want to skip, generate an empty transaction with the same GTID as the transaction + public final static int ER_DUP_UNKNOWN_IN_INDEX = 1859; //SQLSTATE: 23000 Message: Duplicate entry for key '%s' + public final static int ER_IDENT_CAUSES_TOO_LONG_PATH = 1860; //SQLSTATE: HY000 Message: Long database name and identifier for object resulted in path length exceeding %d characters. Path: '%s'. + public final static int ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_NOT_NULL = 1861; //SQLSTATE: HY000 Message: cannot silently convert NULL values, as required in this SQL_MODE; was introduced in 5.7.1. + public final static int ER_MUST_CHANGE_PASSWORD_LOGIN = 1862; //SQLSTATE: HY000 Message: Your password has expired. To log in you must change it using a client that supports expired passwords. was introduced in 5.7.1. + public final static int ER_ROW_IN_WRONG_PARTITION = 1863; //SQLSTATE: HY000 Message: Found a row in wrong partition %s; was introduced in 5.7.1. + public final static int ER_MTS_EVENT_BIGGER_PENDING_JOBS_SIZE_MAX = 1864; //SQLSTATE: HY000 Message: Cannot schedule event %s, relay-log name %s, position %s to Worker thread because its size %lu exceeds %lu of replica_pending_jobs_size_max.; was introduced in 5.7.2. + + public final static int ER_INNODB_NO_FT_USES_PARSER = 1865; //SQLSTATE: HY000 Message: Cannot CREATE FULLTEXT INDEX WITH PARSER on InnoDB table; was introduced in 5.7.2. + public final static int ER_BINLOG_LOGICAL_CORRUPTION = 1866; //SQLSTATE: HY000 Message: The binary log file '%s' is logically corrupted: %s; was introduced in 5.7.2. + public final static int ER_WARN_PURGE_LOG_IN_USE = 1867; //SQLSTATE: HY000 Message: file %s was not purged because it was being read by %d thread(s), purged only %d out of %d files. was introduced in 5.7.2. + public final static int ER_WARN_PURGE_LOG_IS_ACTIVE = 1868; //SQLSTATE: HY000 Message: file %s was not purged because it is the active log file.; was introduced in 5.7.2. + public final static int ER_AUTO_INCREMENT_CONFLICT = 1869; //SQLSTATE: HY000 Message: Auto-increment value in UPDATE conflicts with internally generated values; was introduced in 5.7.2. + public final static int WARN_ON_BLOCKHOLE_IN_RBR = 1870; //SQLSTATE: HY000 Message: Row events are not logged for %s statements that modify BLACKHOLE tables in row format. Table(s): '%s'; was introduced in 5.7.2. + @Deprecated + public final static int ER_SLAVE_MI_INIT_REPOSITORY = 1871; + public final static int ER_REPLICA_MI_INIT_REPOSITORY = 1871; //SQLSTATE: HY000 Message: Replica failed to initialize source info structure from the repository; was introduced in 5.7.2. + @Deprecated + public final static int ER_SLAVE_RLI_INIT_REPOSITORY = 1872; + public final static int ER_REPLICA_RLI_INIT_REPOSITORY = 1872; //SQLSTATE: HY000 Message: Replica failed to initialize relay log info structure from the repository; was introduced in 5.7.2. + public final static int ER_ACCESS_DENIED_CHANGE_USER_ERROR = 1873; //SQLSTATE: 28000 Message: Access denied trying to change to user '%s'@'%s' (using password: %s). Disconnecting. was introduced in 5.7.2. + public final static int ER_INNODB_READ_ONLY = 1874; //SQLSTATE: HY000 Message: InnoDB is in read only mode.; was introduced in 5.7.2. + @Deprecated + public final static int ER_STOP_SLAVE_SQL_THREAD_TIMEOUT = 1875; + public final static int ER_STOP_REPLICA_SQL_THREAD_TIMEOUT = 1875; //SQLSTATE: HY000 Message: STOP REPLICA command execution is incomplete: Replica SQL thread got the stop signal, thread is busy, SQL thread will stop once the current task is complete.; was introduced in 5.7.2. + @Deprecated + public final static int ER_STOP_SLAVE_IO_THREAD_TIMEOUT = 1876; + public final static int ER_STOP_REPLICA_IO_THREAD_TIMEOUT = 1876; //SQLSTATE: HY000 Message: STOP REPLICA command execution is incomplete: Replica IO thread got the stop signal, thread is busy, IO thread will stop once the current task is complete.; was introduced in 5.7.2. + public final static int ER_TABLE_CORRUPT = 1877; //SQLSTATE: HY000 Message: Operation cannot be performed. The table '%s.%s' is missing, corrupt or contains bad data.; was introduced in 5.7.2. + public final static int ER_TEMP_FILE_WRITE_FAILURE = 1878; //SQLSTATE: HY000 Message: Temporary file write failure.; was introduced in 5.7.3. + public final static int ER_INNODB_FT_AUX_NOT_HEX_ID = 1879; //SQLSTATE: HY000 Message: Upgrade index name failed, please use create index(alter table) algorithm copy to rebuild index.; was introduced in 5.7.4. + public final static int ER_OLD_TEMPORALS_UPGRADED = 1880; //SQLSTATE: HY000 Message: TIME/TIMESTAMP/DATETIME columns of old format have been upgraded to the new format.; was introduced in 5.7.4. + public final static int ER_INNODB_FORCED_RECOVERY = 1881; //SQLSTATE: HY000 Message: Operation not allowed when innodb_forced_recovery > 0.; was introduced in 5.7.4. + public final static int ER_AES_INVALID_IV = 1882; //SQLSTATE: HY000 Message: The initialization vector supplied to %s is too short. Must be at least %d bytes long; was introduced in 5.7.4. + public final static int ER_FILE_CORRUPT = 1883; //SQLSTATE: HY000 Message: File %s is corrupted + @Deprecated + public final static int ER_ERROR_ON_MASTER = 1884; + public final static int ER_ERROR_ON_SOURCE = 1884; //SQLSTATE: HY000 Message: Query partially completed on the source (error on source: %d) and was aborted. There is a chance that your source is inconsistent at this point. If you are sure that your source is ok, run this query manually on the replica and then restart the replica with SET GLOBAL SQL_REPLICA_SKIP_COUNTER=1; START REPLICA;. Query:'%s' + public final static int ER_INCONSISTENT_ERROR = 1885; //SQLSTATE: HY000 Message: Query caused different errors on source and replica. Error on source: message (format)='%s' error code=%d; Error on replica:actual message='%s', error code=%d. Default database:'%s'. Query:'%s' + public final static int ER_STORAGE_ENGINE_NOT_LOADED = 1886; //SQLSTATE: HY000 Message: Storage engine for table '%s'.'%s' is not loaded. + public final static int ER_GET_STACKED_DA_WITHOUT_ACTIVE_HANDLER = 1887; //SQLSTATE: 0Z002 Message: GET STACKED DIAGNOSTICS when handler not active + public final static int ER_WARN_LEGACY_SYNTAX_CONVERTED = 1888; //SQLSTATE: HY000 Message: %s is no longer supported. The statement was converted to %s. + public final static int ER_BINLOG_UNSAFE_FULLTEXT_PLUGIN = 1889; //SQLSTATE: HY000 Message: Statement is unsafe because it uses a fulltext parser plugin which may not return the same value on the replica.; was introduced in 5.7.1. + public final static int ER_CANNOT_DISCARD_TEMPORARY_TABLE = 1890; //SQLSTATE: HY000 Message: Cannot DISCARD/IMPORT tablespace associated with temporary table; was introduced in 5.7.1. + public final static int ER_FK_DEPTH_EXCEEDED = 1891; //SQLSTATE: HY000 Message: Foreign key cascade delete/update exceeds max depth of %d.; was introduced in 5.7.2. + public final static int ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE_V2 = 1892; //SQLSTATE: HY000 Message: Column count of %s.%s is wrong. Expected %d, found %d. Created with MySQL %d, now running %d. Please use mysql_upgrade to fix this error.; was introduced in 5.7.2. + public final static int ER_WARN_TRIGGER_DOESNT_HAVE_CREATED = 1893; //SQLSTATE: HY000 Message: Trigger %s.%s.%s does not have CREATED attribute.; was introduced in 5.7.2. + public final static int ER_REFERENCED_TRG_DOES_NOT_EXIST = 1894; //SQLSTATE: HY000 Message: Referenced trigger '%s' for the given action time and event type does not exist.; was introduced in 5.7.2. + public final static int ER_EXPLAIN_NOT_SUPPORTED = 1895; //SQLSTATE: HY000 Message: EXPLAIN FOR CONNECTION command is supported only for SELECT/UPDATE/INSERT/DELETE/REPLACE; was introduced in 5.7.2. + public final static int ER_INVALID_FIELD_SIZE = 1896; //SQLSTATE: HY000 Message: Invalid size for column '%s'.; was introduced in 5.7.2. + public final static int ER_MISSING_HA_CREATE_OPTION = 1897; //SQLSTATE: HY000 Message: Table storage engine '%s' found required create option missing; was introduced in 5.7.2. + public final static int ER_ENGINE_OUT_OF_MEMORY = 1898; //SQLSTATE: HY000 Message: Out of memory in storage engine '%s'.; was introduced in 5.7.3. + public final static int ER_PASSWORD_EXPIRE_ANONYMOUS_USER = 1899; //SQLSTATE: HY000 Message: The password for anonymous user cannot be expired.; was introduced in 5.7.3. + @Deprecated + public final static int ER_SLAVE_SQL_THREAD_MUST_STOP = 1900; + public final static int ER_REPLICA_SQL_THREAD_MUST_STOP = 1900; //SQLSTATE: HY000 Message: This operation cannot be performed with a running replica sql thread; run STOP REPLICA SQL_THREAD first; was introduced in 5.7.3. + public final static int ER_NO_FT_MATERIALIZED_SUBQUERY = 1901; //SQLSTATE: HY000 Message: Cannot create FULLTEXT index on materialized subquery; was introduced in 5.7.4. + public final static int ER_INNODB_UNDO_LOG_FULL = 1902; //SQLSTATE: HY000 Message: Undo Log error: %s; was introduced in 5.7.4. + public final static int ER_INVALID_ARGUMENT_FOR_LOGARITHM = 1903; //SQLSTATE: 2201E Message: Invalid argument for logarithm; was introduced in 5.7.4. + @Deprecated + public final static int ER_SLAVE_IO_THREAD_MUST_STOP = 1904; + public final static int ER_REPLICA_IO_THREAD_MUST_STOP = 1904; //SQLSTATE: HY000 Message: This operation cannot be performed with a running replica io thread; run STOP REPLICA IO_THREAD first.; was introduced in 5.7.4. + public final static int ER_WARN_OPEN_TEMP_TABLES_MUST_BE_ZERO = 1905; //SQLSTATE: HY000 Message: This operation may not be safe when the replica has temporary tables. The tables will be kept open until the server restarts or until the tables are deleted by any replicated DROP statement. Suggest to wait until replica_open_temp_tables = 0.; was introduced in 5.7.4. + @Deprecated + public final static int ER_WARN_ONLY_MASTER_LOG_FILE_NO_POS = 1906; + public final static int ER_WARN_ONLY_SOURCE_LOG_FILE_NO_POS = 1906; //SQLSTATE: HY000 Message: CHANGE SOURCE TO with a SOURCE_LOG_FILE clause but no SOURCE_LOG_POS clause may not be safe. The old position value may not be valid for the new binary log file.; was introduced in 5.7.4. + public final static int ER_QUERY_TIMEOUT = 1907; //SQLSTATE: HY000 Message: Query execution was interrupted, max_statement_time exceeded; was introduced in 5.7.4. + public final static int ER_NON_RO_SELECT_DISABLE_TIMER = 1908; //SQLSTATE: HY000 Message: Select is not a read only statement, disabling timer; was introduced in 5.7.4. + public final static int ER_DUP_LIST_ENTRY = 1909; //SQLSTATE: HY000 Message: Duplicate entry '%s'.; was introduced in 5.7.4. + public final static int ER_SQL_MODE_NO_EFFECT = 1910; //SQLSTATE: HY000 Message: '%s' mode no longer has any effect. Use STRICT_ALL_TABLES or STRICT_TRANS_TABLES instead.; was introduced in 5.7.4. + + public static final int ER_SESSION_WAS_KILLED = 3169; + + public final static int ER_CLIENT_INTERACTION_TIMEOUT = 4031; //SQLSTATE: HY000 Message: The client was disconnected by the server because of inactivity. See wait_timeout and interactive_timeout for configuring this behavior. Was added in 8.0.24. + + public static final int ER_X_BAD_MESSAGE = 5000; + public static final int ER_X_CAPABILITIES_PREPARE_FAILED = 5001; + public static final int ER_X_CAPABILITY_NOT_FOUND = 5002; + public static final int ER_X_INVALID_PROTOCOL_DATA = 5003; + public static final int ER_X_BAD_CONNECTION_SESSION_ATTRIBUTE_VALUE_LENGTH = 5004; + public static final int ER_X_BAD_CONNECTION_SESSION_ATTRIBUTE_KEY_LENGTH = 5005; + public static final int ER_X_BAD_CONNECTION_SESSION_ATTRIBUTE_EMPTY_KEY = 5006; + public static final int ER_X_BAD_CONNECTION_SESSION_ATTRIBUTE_LENGTH = 5007; + public static final int ER_X_BAD_CONNECTION_SESSION_ATTRIBUTE_TYPE = 5008; + public static final int ER_X_CAPABILITY_SET_NOT_ALLOWED = 5009; + public static final int ER_X_SERVICE_ERROR = 5010; + public static final int ER_X_SESSION = 5011; + public static final int ER_X_INVALID_ARGUMENT = 5012; + public static final int ER_X_MISSING_ARGUMENT = 5013; + public static final int ER_X_BAD_INSERT_DATA = 5014; + public static final int ER_X_CMD_NUM_ARGUMENTS = 5015; + public static final int ER_X_CMD_ARGUMENT_TYPE = 5016; + public static final int ER_X_CMD_ARGUMENT_VALUE = 5017; + public static final int ER_X_BAD_UPSERT_DATA = 5018; + public static final int ER_X_DUPLICATED_CAPABILITIES = 5019; + public static final int ER_X_CMD_ARGUMENT_OBJECT_EMPTY = 5020; + public static final int ER_X_CMD_INVALID_ARGUMENT = 5021; + public static final int ER_X_BAD_UPDATE_DATA = 5050; + public static final int ER_X_BAD_TYPE_OF_UPDATE = 5051; + public static final int ER_X_BAD_COLUMN_TO_UPDATE = 5052; + public static final int ER_X_BAD_MEMBER_TO_UPDATE = 5053; + public static final int ER_X_BAD_STATEMENT_ID = 5110; + public static final int ER_X_BAD_CURSOR_ID = 5111; + public static final int ER_X_BAD_SCHEMA = 5112; + public static final int ER_X_BAD_TABLE = 5113; + public static final int ER_X_BAD_PROJECTION = 5114; + public static final int ER_X_DOC_ID_MISSING = 5115; + public static final int ER_X_DUPLICATE_ENTRY = 5116; + public static final int ER_X_DOC_REQUIRED_FIELD_MISSING = 5117; + public static final int ER_X_PROJ_BAD_KEY_NAME = 5120; + public static final int ER_X_BAD_DOC_PATH = 5121; + public static final int ER_X_CURSOR_EXISTS = 5122; + public static final int ER_X_PREPARED_STATMENT_CAN_HAVE_ONE_CURSOR = 5131; + public static final int ER_X_PREPARED_EXECUTE_ARGUMENT_NOT_SUPPORTED = 5133; + public static final int ER_X_PREPARED_EXECUTE_ARGUMENT_CONSISTENCY = 5134; + public static final int ER_X_CURSOR_REACHED_EOF = 5123; + public static final int ER_X_EXPR_BAD_OPERATOR = 5150; + public static final int ER_X_EXPR_BAD_NUM_ARGS = 5151; + public static final int ER_X_EXPR_MISSING_ARG = 5152; + public static final int ER_X_EXPR_BAD_TYPE_VALUE = 5153; + public static final int ER_X_EXPR_BAD_VALUE = 5154; + public static final int ER_X_EXPR_BAD_REGEX = 5155; + public static final int ER_X_INVALID_COLLECTION = 5156; + public static final int ER_X_INVALID_ADMIN_COMMAND = 5157; + public static final int ER_X_EXPECT_NOT_OPEN = 5158; + public static final int ER_X_EXPECT_NO_ERROR_FAILED = 5159; + public static final int ER_X_EXPECT_BAD_CONDITION = 5160; + public static final int ER_X_EXPECT_BAD_CONDITION_VALUE = 5161; + public static final int ER_X_INVALID_NAMESPACE = 5162; + public static final int ER_X_BAD_NOTICE = 5163; + public static final int ER_X_CANNOT_DISABLE_NOTICE = 5164; + public static final int ER_X_BAD_CONFIGURATION = 5165; + public static final int ER_X_MYSQLX_ACCOUNT_MISSING_PERMISSIONS = 5167; + public static final int ER_X_EXPECT_FIELD_EXISTS_FAILED = 5168; + public static final int ER_X_BAD_LOCKING = 5169; + public static final int ER_X_FRAME_COMPRESSION_DISABLED = 5170; + public static final int ER_X_DECOMPRESSION_FAILED = 5171; + public static final int ER_X_BAD_COMPRESSED_FRAME = 5174; + public static final int ER_X_CAPABILITY_COMPRESSION_INVALID_ALGORITHM = 5175; + public static final int ER_X_CAPABILITY_COMPRESSION_INVALID_SERVER_STYLE = 5176; + public static final int ER_X_CAPABILITY_COMPRESSION_INVALID_CLIENT_STYLE = 5177; + public static final int ER_X_CAPABILITY_COMPRESSION_INVALID_OPTION = 5178; + public static final int ER_X_CAPABILITY_COMPRESSION_MISSING_REQUIRED_FIELDS = 5179; + public static final int ER_X_DOCUMENT_DOESNT_MATCH_EXPECTED_SCHEMA = 5180; + public static final int ER_X_COLLECTION_OPTION_DOESNT_EXISTS = 5181; + public static final int ER_X_INVALID_VALIDATION_SCHEMA = 5182; + + // Connector/J-specific errors outside the space of server errors. + public static final int ERROR_CODE_NULL_LOAD_BALANCED_CONNECTION = 1000001; + public static final int ERROR_CODE_REPLICATION_CONNECTION_WITH_NO_HOSTS = 1000002; + + // SQL-92 + public static final String SQL_STATE_WARNING = "01000"; + public static final String SQL_STATE_DISCONNECT_ERROR = "01002"; + public static final String SQL_STATE_DATE_TRUNCATED = "01004"; + public static final String SQL_STATE_PRIVILEGE_NOT_REVOKED = "01006"; + public static final String SQL_STATE_NO_DATA = "02000"; + public static final String SQL_STATE_WRONG_NO_OF_PARAMETERS = "07001"; + public static final String SQL_STATE_UNABLE_TO_CONNECT_TO_DATASOURCE = "08001"; + public static final String SQL_STATE_CONNECTION_IN_USE = "08002"; + public static final String SQL_STATE_CONNECTION_NOT_OPEN = "08003"; + public static final String SQL_STATE_CONNECTION_REJECTED = "08004"; + public static final String SQL_STATE_CONNECTION_FAILURE = "08006"; + public static final String SQL_STATE_TRANSACTION_RESOLUTION_UNKNOWN = "08007"; + public static final String SQL_STATE_COMMUNICATION_LINK_FAILURE = "08S01"; + public static final String SQL_STATE_FEATURE_NOT_SUPPORTED = "0A000"; + public static final String SQL_STATE_CARDINALITY_VIOLATION = "21000"; + public static final String SQL_STATE_INSERT_VALUE_LIST_NO_MATCH_COL_LIST = "21S01"; + public static final String SQL_STATE_STRING_DATA_RIGHT_TRUNCATION = "22001"; + public static final String SQL_STATE_NUMERIC_VALUE_OUT_OF_RANGE = "22003"; + public static final String SQL_STATE_INVALID_DATETIME_FORMAT = "22007"; + public static final String SQL_STATE_DATETIME_FIELD_OVERFLOW = "22008"; + public static final String SQL_STATE_DIVISION_BY_ZERO = "22012"; + public static final String SQL_STATE_INVALID_CHARACTER_VALUE_FOR_CAST = "22018"; + public static final String SQL_STATE_INTEGRITY_CONSTRAINT_VIOLATION = "23000"; + public static final String SQL_STATE_INVALID_CURSOR_STATE = "24000"; + public static final String SQL_STATE_INVALID_TRANSACTION_STATE = "25000"; + public static final String SQL_STATE_INVALID_AUTH_SPEC = "28000"; + public static final String SQL_STATE_INVALID_TRANSACTION_TERMINATION = "2D000"; + public static final String SQL_STATE_INVALID_CONDITION_NUMBER = "35000"; + public static final String SQL_STATE_INVALID_CATALOG_NAME = "3D000"; + public static final String SQL_STATE_ROLLBACK_SERIALIZATION_FAILURE = "40001"; + public static final String SQL_STATE_SYNTAX_ERROR = "42000"; + public static final String SQL_STATE_ER_TABLE_EXISTS_ERROR = "42S01"; + public static final String SQL_STATE_BASE_TABLE_OR_VIEW_NOT_FOUND = "42S02"; + public static final String SQL_STATE_ER_NO_SUCH_INDEX = "42S12"; + public static final String SQL_STATE_ER_DUP_FIELDNAME = "42S21"; + public static final String SQL_STATE_ER_BAD_FIELD_ERROR = "42S22"; + + // SQL-99 + public static final String SQL_STATE_INVALID_CONNECTION_ATTRIBUTE = "01S00"; + public static final String SQL_STATE_ERROR_IN_ROW = "01S01"; + public static final String SQL_STATE_NO_ROWS_UPDATED_OR_DELETED = "01S03"; + public static final String SQL_STATE_MORE_THAN_ONE_ROW_UPDATED_OR_DELETED = "01S04"; + public static final String SQL_STATE_RESIGNAL_WHEN_HANDLER_NOT_ACTIVE = "0K000"; + public static final String SQL_STATE_STACKED_DIAGNOSTICS_ACCESSED_WITHOUT_ACTIVE_HANDLER = "0Z002"; + public static final String SQL_STATE_CASE_NOT_FOUND_FOR_CASE_STATEMENT = "20000"; + public static final String SQL_STATE_NULL_VALUE_NOT_ALLOWED = "22004"; + public static final String SQL_STATE_INVALID_LOGARITHM_ARGUMENT = "2201E"; + public static final String SQL_STATE_ACTIVE_SQL_TRANSACTION = "25001"; + public static final String SQL_STATE_READ_ONLY_SQL_TRANSACTION = "25006"; + public static final String SQL_STATE_SRE_PROHIBITED_SQL_STATEMENT_ATTEMPTED = "2F003"; + public static final String SQL_STATE_SRE_FUNCTION_EXECUTED_NO_RETURN_STATEMENT = "2F005"; + public static final String SQL_STATE_ER_QUERY_INTERRUPTED = "70100"; // non-standard ? + public static final String SQL_STATE_BASE_TABLE_OR_VIEW_ALREADY_EXISTS = "S0001"; + public static final String SQL_STATE_BASE_TABLE_NOT_FOUND = "S0002"; + public static final String SQL_STATE_INDEX_ALREADY_EXISTS = "S0011"; + public static final String SQL_STATE_INDEX_NOT_FOUND = "S0012"; + public static final String SQL_STATE_COLUMN_ALREADY_EXISTS = "S0021"; + public static final String SQL_STATE_COLUMN_NOT_FOUND = "S0022"; + public static final String SQL_STATE_NO_DEFAULT_FOR_COLUMN = "S0023"; + public static final String SQL_STATE_GENERAL_ERROR = "S1000"; + public static final String SQL_STATE_MEMORY_ALLOCATION_FAILURE = "S1001"; + public static final String SQL_STATE_INVALID_COLUMN_NUMBER = "S1002"; + public static final String SQL_STATE_ILLEGAL_ARGUMENT = "S1009"; + public static final String SQL_STATE_DRIVER_NOT_CAPABLE = "S1C00"; + public static final String SQL_STATE_TIMEOUT_EXPIRED = "S1T00"; + public static final String SQL_STATE_CLI_SPECIFIC_CONDITION = "HY000"; + public static final String SQL_STATE_MEMORY_ALLOCATION_ERROR = "HY001"; + public static final String SQL_STATE_XA_RBROLLBACK = "XA100"; + public static final String SQL_STATE_XA_RBDEADLOCK = "XA102"; + public static final String SQL_STATE_XA_RBTIMEOUT = "XA106"; + public static final String SQL_STATE_XA_RMERR = "XAE03"; + public static final String SQL_STATE_XAER_NOTA = "XAE04"; + public static final String SQL_STATE_XAER_INVAL = "XAE05"; + public static final String SQL_STATE_XAER_RMFAIL = "XAE07"; + public static final String SQL_STATE_XAER_DUPID = "XAE08"; + public static final String SQL_STATE_XAER_OUTSIDE = "XAE09"; + + public static final String SQL_STATE_BAD_SSL_PARAMS = "08000"; + + private static Map sqlStateMessages; + + public static Map mysqlToSql99State; + + static { + + sqlStateMessages = new HashMap<>(); + sqlStateMessages.put(SQL_STATE_DISCONNECT_ERROR, Messages.getString("SQLError.35")); + sqlStateMessages.put(SQL_STATE_DATE_TRUNCATED, Messages.getString("SQLError.36")); + sqlStateMessages.put(SQL_STATE_PRIVILEGE_NOT_REVOKED, Messages.getString("SQLError.37")); + sqlStateMessages.put(SQL_STATE_INVALID_CONNECTION_ATTRIBUTE, Messages.getString("SQLError.38")); + sqlStateMessages.put(SQL_STATE_ERROR_IN_ROW, Messages.getString("SQLError.39")); + sqlStateMessages.put(SQL_STATE_NO_ROWS_UPDATED_OR_DELETED, Messages.getString("SQLError.40")); + sqlStateMessages.put(SQL_STATE_MORE_THAN_ONE_ROW_UPDATED_OR_DELETED, Messages.getString("SQLError.41")); + sqlStateMessages.put(SQL_STATE_WRONG_NO_OF_PARAMETERS, Messages.getString("SQLError.42")); + sqlStateMessages.put(SQL_STATE_UNABLE_TO_CONNECT_TO_DATASOURCE, Messages.getString("SQLError.43")); + sqlStateMessages.put(SQL_STATE_CONNECTION_IN_USE, Messages.getString("SQLError.44")); + sqlStateMessages.put(SQL_STATE_CONNECTION_NOT_OPEN, Messages.getString("SQLError.45")); + sqlStateMessages.put(SQL_STATE_CONNECTION_REJECTED, Messages.getString("SQLError.46")); + sqlStateMessages.put(SQL_STATE_TRANSACTION_RESOLUTION_UNKNOWN, Messages.getString("SQLError.47")); + sqlStateMessages.put(SQL_STATE_COMMUNICATION_LINK_FAILURE, Messages.getString("SQLError.48")); + sqlStateMessages.put(SQL_STATE_INSERT_VALUE_LIST_NO_MATCH_COL_LIST, Messages.getString("SQLError.49")); + sqlStateMessages.put(SQL_STATE_NUMERIC_VALUE_OUT_OF_RANGE, Messages.getString("SQLError.50")); + sqlStateMessages.put(SQL_STATE_DATETIME_FIELD_OVERFLOW, Messages.getString("SQLError.51")); + sqlStateMessages.put(SQL_STATE_DIVISION_BY_ZERO, Messages.getString("SQLError.52")); + sqlStateMessages.put(SQL_STATE_ROLLBACK_SERIALIZATION_FAILURE, Messages.getString("SQLError.53")); + sqlStateMessages.put(SQL_STATE_INVALID_AUTH_SPEC, Messages.getString("SQLError.54")); + sqlStateMessages.put(SQL_STATE_SYNTAX_ERROR, Messages.getString("SQLError.55")); + sqlStateMessages.put(SQL_STATE_BASE_TABLE_OR_VIEW_NOT_FOUND, Messages.getString("SQLError.56")); + sqlStateMessages.put(SQL_STATE_BASE_TABLE_OR_VIEW_ALREADY_EXISTS, Messages.getString("SQLError.57")); + sqlStateMessages.put(SQL_STATE_BASE_TABLE_NOT_FOUND, Messages.getString("SQLError.58")); + sqlStateMessages.put(SQL_STATE_INDEX_ALREADY_EXISTS, Messages.getString("SQLError.59")); + sqlStateMessages.put(SQL_STATE_INDEX_NOT_FOUND, Messages.getString("SQLError.60")); + sqlStateMessages.put(SQL_STATE_COLUMN_ALREADY_EXISTS, Messages.getString("SQLError.61")); + sqlStateMessages.put(SQL_STATE_COLUMN_NOT_FOUND, Messages.getString("SQLError.62")); + sqlStateMessages.put(SQL_STATE_NO_DEFAULT_FOR_COLUMN, Messages.getString("SQLError.63")); + sqlStateMessages.put(SQL_STATE_GENERAL_ERROR, Messages.getString("SQLError.64")); + sqlStateMessages.put(SQL_STATE_MEMORY_ALLOCATION_FAILURE, Messages.getString("SQLError.65")); + sqlStateMessages.put(SQL_STATE_INVALID_COLUMN_NUMBER, Messages.getString("SQLError.66")); + sqlStateMessages.put(SQL_STATE_ILLEGAL_ARGUMENT, Messages.getString("SQLError.67")); + sqlStateMessages.put(SQL_STATE_DRIVER_NOT_CAPABLE, Messages.getString("SQLError.68")); + sqlStateMessages.put(SQL_STATE_TIMEOUT_EXPIRED, Messages.getString("SQLError.69")); + + mysqlToSql99State = new HashMap<>(); + + mysqlToSql99State.put(MysqlErrorNumbers.ER_SELECT_REDUCED, SQL_STATE_WARNING); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WARN_TOO_FEW_RECORDS, SQL_STATE_WARNING); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WARN_TOO_MANY_RECORDS, SQL_STATE_WARNING); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WARN_DATA_TRUNCATED, SQL_STATE_WARNING); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WARN_NULL_TO_NOTNULL, SQL_STATE_NULL_VALUE_NOT_ALLOWED); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WARN_DATA_OUT_OF_RANGE, SQL_STATE_NUMERIC_VALUE_OUT_OF_RANGE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_UNINIT_VAR, SQL_STATE_WARNING); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SIGNAL_WARN, SQL_STATE_WARNING); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_FETCH_NO_DATA, SQL_STATE_NO_DATA); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SIGNAL_NOT_FOUND, SQL_STATE_NO_DATA); + mysqlToSql99State.put(MysqlErrorNumbers.ER_CON_COUNT_ERROR, SQL_STATE_CONNECTION_REJECTED); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NOT_SUPPORTED_AUTH_MODE, SQL_STATE_CONNECTION_REJECTED); + mysqlToSql99State.put(MysqlErrorNumbers.ER_BAD_HOST_ERROR, SQL_STATE_COMMUNICATION_LINK_FAILURE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_HANDSHAKE_ERROR, SQL_STATE_COMMUNICATION_LINK_FAILURE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_UNKNOWN_COM_ERROR, SQL_STATE_COMMUNICATION_LINK_FAILURE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SERVER_SHUTDOWN, SQL_STATE_COMMUNICATION_LINK_FAILURE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_FORCING_CLOSE, SQL_STATE_COMMUNICATION_LINK_FAILURE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_IPSOCK_ERROR, SQL_STATE_COMMUNICATION_LINK_FAILURE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_ABORTING_CONNECTION, SQL_STATE_COMMUNICATION_LINK_FAILURE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NET_PACKET_TOO_LARGE, SQL_STATE_COMMUNICATION_LINK_FAILURE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NET_READ_ERROR_FROM_PIPE, SQL_STATE_COMMUNICATION_LINK_FAILURE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NET_FCNTL_ERROR, SQL_STATE_COMMUNICATION_LINK_FAILURE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NET_PACKETS_OUT_OF_ORDER, SQL_STATE_COMMUNICATION_LINK_FAILURE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NET_UNCOMPRESS_ERROR, SQL_STATE_COMMUNICATION_LINK_FAILURE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NET_READ_ERROR, SQL_STATE_COMMUNICATION_LINK_FAILURE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NET_READ_INTERRUPTED, SQL_STATE_COMMUNICATION_LINK_FAILURE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NET_ERROR_ON_WRITE, SQL_STATE_COMMUNICATION_LINK_FAILURE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NET_WRITE_INTERRUPTED, SQL_STATE_COMMUNICATION_LINK_FAILURE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NEW_ABORTING_CONNECTION, SQL_STATE_COMMUNICATION_LINK_FAILURE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SOURCE_NET_READ, SQL_STATE_COMMUNICATION_LINK_FAILURE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SOURCE_NET_WRITE, SQL_STATE_COMMUNICATION_LINK_FAILURE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_CONNECT_TO_SOURCE, SQL_STATE_COMMUNICATION_LINK_FAILURE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_BADSELECT, SQL_STATE_FEATURE_NOT_SUPPORTED); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_BADSTATEMENT, SQL_STATE_FEATURE_NOT_SUPPORTED); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_SUBSELECT_NYI, SQL_STATE_FEATURE_NOT_SUPPORTED); + mysqlToSql99State.put(MysqlErrorNumbers.ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG, SQL_STATE_FEATURE_NOT_SUPPORTED); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_NO_RETSET, SQL_STATE_FEATURE_NOT_SUPPORTED); + mysqlToSql99State.put(MysqlErrorNumbers.ER_ALTER_OPERATION_NOT_SUPPORTED, SQL_STATE_FEATURE_NOT_SUPPORTED); + mysqlToSql99State.put(MysqlErrorNumbers.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON, SQL_STATE_FEATURE_NOT_SUPPORTED); + mysqlToSql99State.put(MysqlErrorNumbers.ER_DBACCESS_DENIED_ERROR, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_BAD_DB_ERROR, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_FIELD_WITH_GROUP, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_GROUP_FIELD, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_SUM_SELECT, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TOO_LONG_IDENT, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_DUP_KEYNAME, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_FIELD_SPEC, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_PARSE_ERROR, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_EMPTY_QUERY, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NONUNIQ_TABLE, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_INVALID_DEFAULT, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_MULTIPLE_PRI_KEY, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TOO_MANY_KEYS, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TOO_MANY_KEY_PARTS, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TOO_LONG_KEY, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_KEY_COLUMN_DOES_NOT_EXITS, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_BLOB_USED_AS_KEY, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TOO_BIG_FIELDLENGTH, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_AUTO_KEY, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_FIELD_TERMINATORS, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_BLOBS_AND_NO_TERMINATED, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_CANT_REMOVE_ALL_FIELDS, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_CANT_DROP_FIELD_OR_KEY, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_BLOB_CANT_HAVE_DEFAULT, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_DB_NAME, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_TABLE_NAME, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TOO_BIG_SELECT, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_UNKNOWN_PROCEDURE, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_PARAMCOUNT_TO_PROCEDURE, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_FIELD_SPECIFIED_TWICE, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_UNSUPPORTED_EXTENSION, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TABLE_MUST_HAVE_COLUMNS, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_UNKNOWN_CHARACTER_SET, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TOO_BIG_ROWSIZE, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_OUTER_JOIN, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NULL_COLUMN_IN_INDEX, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_PASSWORD_ANONYMOUS_USER, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_PASSWORD_NOT_ALLOWED, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_PASSWORD_NO_MATCH, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_REGEXP_ERROR, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_MIX_OF_GROUP_FUNC_AND_FIELDS, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NONEXISTING_GRANT, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TABLEACCESS_DENIED_ERROR, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_COLUMNACCESS_DENIED_ERROR, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_ILLEGAL_GRANT_FOR_TABLE, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_GRANT_WRONG_HOST_OR_USER, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NONEXISTING_TABLE_GRANT, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NOT_ALLOWED_COMMAND, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SYNTAX_ERROR, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TOO_LONG_STRING, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TABLE_CANT_HANDLE_BLOB, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TABLE_CANT_HANDLE_AUTO_INCREMENT, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_COLUMN_NAME, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_KEY_COLUMN, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_BLOB_KEY_WITHOUT_LENGTH, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_PRIMARY_CANT_HAVE_NULL, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TOO_MANY_ROWS, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_REQUIRES_PRIMARY_KEY, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_KEY_DOES_NOT_EXITS, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_CHECK_NO_SUCH_TABLE, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_CHECK_NOT_IMPLEMENTED, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TOO_MANY_USER_CONNECTIONS, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NO_PERMISSION_TO_CREATE_USER, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_USER_LIMIT_REACHED, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SPECIFIC_ACCESS_DENIED_ERROR, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NO_DEFAULT, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_VALUE_FOR_VAR, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_TYPE_FOR_VAR, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_CANT_USE_OPTION_HERE, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NOT_SUPPORTED_YET, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_FK_DEF, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_DERIVED_MUST_HAVE_ALIAS, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TABLENAME_NOT_ALLOWED_HERE, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SPATIAL_CANT_HAVE_NULL, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_COLLATION_CHARSET_MISMATCH, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_NAME_FOR_INDEX, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_NAME_FOR_CATALOG, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_UNKNOWN_STORAGE_ENGINE, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_ALREADY_EXISTS, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_DOES_NOT_EXIST, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_LILABEL_MISMATCH, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_LABEL_REDEFINE, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_LABEL_MISMATCH, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_BADRETURN, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_UPDATE_LOG_DEPRECATED_IGNORED, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_UPDATE_LOG_DEPRECATED_TRANSLATED, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_WRONG_NO_OF_ARGS, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_COND_MISMATCH, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_NORETURN, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_BAD_CURSOR_QUERY, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_BAD_CURSOR_SELECT, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_CURSOR_MISMATCH, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_UNDECLARED_VAR, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_DUP_PARAM, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_DUP_VAR, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_DUP_COND, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_DUP_CURS, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_VARCOND_AFTER_CURSHNDLR, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_CURSOR_AFTER_HANDLER, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_PROCACCESS_DENIED_ERROR, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NONEXISTING_PROC_GRANT, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_BAD_SQLSTATE, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_CANT_CREATE_USER_WITH_GRANT, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_DUP_HANDLER, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_NOT_VAR_ARG, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TOO_BIG_SCALE, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TOO_BIG_PRECISION, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_M_BIGGER_THAN_D, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TOO_LONG_BODY, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TOO_BIG_DISPLAYWIDTH, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_BAD_VAR_SHADOW, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_WRONG_NAME, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_NO_AGGREGATE, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_MAX_PREPARED_STMT_COUNT_REACHED, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NON_GROUPING_FIELD_USED, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_PARAMETERS_TO_NATIVE_FCT, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_PARAMETERS_TO_STORED_FCT, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_FUNC_INEXISTENT_NAME_COLLISION, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_DUP_SIGNAL_SET, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SPATIAL_MUST_HAVE_GEOM_COL, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TRUNCATE_ILLEGAL_FK, SQL_STATE_SYNTAX_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT, SQL_STATE_CARDINALITY_VIOLATION); + mysqlToSql99State.put(MysqlErrorNumbers.ER_OPERAND_COLUMNS, SQL_STATE_CARDINALITY_VIOLATION); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SUBQUERY_NO_1_ROW, SQL_STATE_CARDINALITY_VIOLATION); + mysqlToSql99State.put(MysqlErrorNumbers.ER_DUP_KEY, SQL_STATE_INTEGRITY_CONSTRAINT_VIOLATION); + mysqlToSql99State.put(MysqlErrorNumbers.ER_BAD_NULL_ERROR, SQL_STATE_INTEGRITY_CONSTRAINT_VIOLATION); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NON_UNIQ_ERROR, SQL_STATE_INTEGRITY_CONSTRAINT_VIOLATION); + mysqlToSql99State.put(MysqlErrorNumbers.ER_DUP_ENTRY, SQL_STATE_INTEGRITY_CONSTRAINT_VIOLATION); + mysqlToSql99State.put(MysqlErrorNumbers.ER_DUP_UNIQUE, SQL_STATE_INTEGRITY_CONSTRAINT_VIOLATION); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NO_REFERENCED_ROW, SQL_STATE_INTEGRITY_CONSTRAINT_VIOLATION); + mysqlToSql99State.put(MysqlErrorNumbers.ER_ROW_IS_REFERENCED, SQL_STATE_INTEGRITY_CONSTRAINT_VIOLATION); + mysqlToSql99State.put(MysqlErrorNumbers.ER_ROW_IS_REFERENCED_2, SQL_STATE_INTEGRITY_CONSTRAINT_VIOLATION); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NO_REFERENCED_ROW_2, SQL_STATE_INTEGRITY_CONSTRAINT_VIOLATION); + mysqlToSql99State.put(MysqlErrorNumbers.ER_FOREIGN_DUPLICATE_KEY, SQL_STATE_INTEGRITY_CONSTRAINT_VIOLATION); + mysqlToSql99State.put(MysqlErrorNumbers.ER_DUP_ENTRY_WITH_KEY_NAME, SQL_STATE_INTEGRITY_CONSTRAINT_VIOLATION); + mysqlToSql99State.put(MysqlErrorNumbers.ER_FOREIGN_DUPLICATE_KEY_WITH_CHILD_INFO, SQL_STATE_INTEGRITY_CONSTRAINT_VIOLATION); + mysqlToSql99State.put(MysqlErrorNumbers.ER_FOREIGN_DUPLICATE_KEY_WITHOUT_CHILD_INFO, SQL_STATE_INTEGRITY_CONSTRAINT_VIOLATION); + mysqlToSql99State.put(MysqlErrorNumbers.ER_DUP_UNKNOWN_IN_INDEX, SQL_STATE_INTEGRITY_CONSTRAINT_VIOLATION); + mysqlToSql99State.put(MysqlErrorNumbers.ER_DATA_TOO_LONG, SQL_STATE_STRING_DATA_RIGHT_TRUNCATION); + mysqlToSql99State.put(MysqlErrorNumbers.ER_CANT_CREATE_GEOMETRY_OBJECT, SQL_STATE_NUMERIC_VALUE_OUT_OF_RANGE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_DATA_OUT_OF_RANGE, SQL_STATE_NUMERIC_VALUE_OUT_OF_RANGE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TRUNCATED_WRONG_VALUE, SQL_STATE_INVALID_DATETIME_FORMAT); + mysqlToSql99State.put(MysqlErrorNumbers.ER_ILLEGAL_VALUE_FOR_TYPE, SQL_STATE_INVALID_DATETIME_FORMAT); + mysqlToSql99State.put(MysqlErrorNumbers.ER_DATETIME_FUNCTION_OVERFLOW, SQL_STATE_DATETIME_FIELD_OVERFLOW); + mysqlToSql99State.put(MysqlErrorNumbers.ER_DIVISION_BY_ZERO, SQL_STATE_DIVISION_BY_ZERO); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_CURSOR_ALREADY_OPEN, SQL_STATE_INVALID_CURSOR_STATE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_CURSOR_NOT_OPEN, SQL_STATE_INVALID_CURSOR_STATE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_CANT_DO_THIS_DURING_AN_TRANSACTION, SQL_STATE_INVALID_TRANSACTION_STATE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_READ_ONLY_TRANSACTION, SQL_STATE_INVALID_TRANSACTION_STATE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_ACCESS_DENIED_ERROR, SQL_STATE_INVALID_AUTH_SPEC); + mysqlToSql99State.put(MysqlErrorNumbers.ER_ACCESS_DENIED_NO_PASSWORD_ERROR, SQL_STATE_INVALID_AUTH_SPEC); + mysqlToSql99State.put(MysqlErrorNumbers.ER_ACCESS_DENIED_CHANGE_USER_ERROR, SQL_STATE_INVALID_AUTH_SPEC); + mysqlToSql99State.put(MysqlErrorNumbers.ER_DA_INVALID_CONDITION_NUMBER, SQL_STATE_INVALID_CONDITION_NUMBER); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NO_DB_ERROR, SQL_STATE_INVALID_CATALOG_NAME); + mysqlToSql99State.put(MysqlErrorNumbers.ER_RESIGNAL_WITHOUT_ACTIVE_HANDLER, SQL_STATE_RESIGNAL_WHEN_HANDLER_NOT_ACTIVE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_GET_STACKED_DA_WITHOUT_ACTIVE_HANDLER, SQL_STATE_STACKED_DIAGNOSTICS_ACCESSED_WITHOUT_ACTIVE_HANDLER); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_CASE_NOT_FOUND, SQL_STATE_CASE_NOT_FOUND_FOR_CASE_STATEMENT); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_VALUE_COUNT, SQL_STATE_INSERT_VALUE_LIST_NO_MATCH_COL_LIST); + mysqlToSql99State.put(MysqlErrorNumbers.ER_WRONG_VALUE_COUNT_ON_ROW, SQL_STATE_INSERT_VALUE_LIST_NO_MATCH_COL_LIST); + mysqlToSql99State.put(MysqlErrorNumbers.ER_INVALID_USE_OF_NULL, SQL_STATE_NULL_VALUE_NOT_ALLOWED); + mysqlToSql99State.put(MysqlErrorNumbers.ER_INVALID_ARGUMENT_FOR_LOGARITHM, SQL_STATE_INVALID_LOGARITHM_ARGUMENT); + mysqlToSql99State.put(MysqlErrorNumbers.ER_CANT_CHANGE_TX_ISOLATION, SQL_STATE_ACTIVE_SQL_TRANSACTION); + mysqlToSql99State.put(MysqlErrorNumbers.ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION, SQL_STATE_READ_ONLY_SQL_TRANSACTION); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_NO_RECURSIVE_CREATE, SQL_STATE_SRE_PROHIBITED_SQL_STATEMENT_ATTEMPTED); + mysqlToSql99State.put(MysqlErrorNumbers.ER_SP_NORETURNEND, SQL_STATE_SRE_FUNCTION_EXECUTED_NO_RETURN_STATEMENT); + mysqlToSql99State.put(MysqlErrorNumbers.ER_TABLE_EXISTS_ERROR, SQL_STATE_ER_TABLE_EXISTS_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_BAD_TABLE_ERROR, SQL_STATE_BASE_TABLE_OR_VIEW_NOT_FOUND); + mysqlToSql99State.put(MysqlErrorNumbers.ER_UNKNOWN_TABLE, SQL_STATE_BASE_TABLE_OR_VIEW_NOT_FOUND); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NO_SUCH_TABLE, SQL_STATE_BASE_TABLE_OR_VIEW_NOT_FOUND); + mysqlToSql99State.put(MysqlErrorNumbers.ER_NO_SUCH_INDEX, SQL_STATE_ER_NO_SUCH_INDEX); + mysqlToSql99State.put(MysqlErrorNumbers.ER_DUP_FIELDNAME, SQL_STATE_ER_DUP_FIELDNAME); + mysqlToSql99State.put(MysqlErrorNumbers.ER_BAD_FIELD_ERROR, SQL_STATE_ER_BAD_FIELD_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_ILLEGAL_REFERENCE, SQL_STATE_ER_BAD_FIELD_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_QUERY_INTERRUPTED, SQL_STATE_ER_QUERY_INTERRUPTED); + mysqlToSql99State.put(MysqlErrorNumbers.ER_OUTOFMEMORY, SQL_STATE_MEMORY_ALLOCATION_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_OUT_OF_SORTMEMORY, SQL_STATE_MEMORY_ALLOCATION_ERROR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_XA_RBROLLBACK, SQL_STATE_XA_RBROLLBACK); + mysqlToSql99State.put(MysqlErrorNumbers.ER_XA_RBDEADLOCK, SQL_STATE_XA_RBDEADLOCK); + mysqlToSql99State.put(MysqlErrorNumbers.ER_XA_RBTIMEOUT, SQL_STATE_XA_RBTIMEOUT); + mysqlToSql99State.put(MysqlErrorNumbers.ER_XA_RMERR, SQL_STATE_XA_RMERR); + mysqlToSql99State.put(MysqlErrorNumbers.ER_XAER_NOTA, SQL_STATE_XAER_NOTA); + mysqlToSql99State.put(MysqlErrorNumbers.ER_XAER_INVAL, SQL_STATE_XAER_INVAL); + mysqlToSql99State.put(MysqlErrorNumbers.ER_XAER_RMFAIL, SQL_STATE_XAER_RMFAIL); + mysqlToSql99State.put(MysqlErrorNumbers.ER_XAER_DUPID, SQL_STATE_XAER_DUPID); + mysqlToSql99State.put(MysqlErrorNumbers.ER_XAER_OUTSIDE, SQL_STATE_XAER_OUTSIDE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_LOCK_WAIT_TIMEOUT, SQL_STATE_ROLLBACK_SERIALIZATION_FAILURE); + mysqlToSql99State.put(MysqlErrorNumbers.ER_LOCK_DEADLOCK, SQL_STATE_ROLLBACK_SERIALIZATION_FAILURE); + } + + public static String get(String stateCode) { + return sqlStateMessages.get(stateCode); + } + + public static String mysqlToSql99(int errno) { + Integer err = Integer.valueOf(errno); + + if (mysqlToSql99State.containsKey(err)) { + return mysqlToSql99State.get(err); + } + + return SQL_STATE_CLI_SPECIFIC_CONDITION; + } + + /** + * Map MySQL error codes to SQL-99 error codes + * + * @param errno + * the MySQL error code + * + * @return the corresponding SQL-99 error code + */ + public static String mysqlToSqlState(int errno) { + return mysqlToSql99(errno); + } + + private MysqlErrorNumbers() { + // prevent instantiation + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/NumberOutOfRange.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/NumberOutOfRange.java new file mode 100644 index 0000000..39ce10d --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/NumberOutOfRange.java @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +/** + * Indicates that a number was out of the expected range. + */ +public class NumberOutOfRange extends DataReadException { + private static final long serialVersionUID = -61091413023651438L; + + public NumberOutOfRange(String msg) { + super(msg); + setSQLState("22003"); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/OperationCancelledException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/OperationCancelledException.java new file mode 100644 index 0000000..982c4a6 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/OperationCancelledException.java @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +import com.mysql.cj.Messages; + +public class OperationCancelledException extends CJException { + + private static final long serialVersionUID = 9001418688349454695L; + + public OperationCancelledException() { + super(Messages.getString("MySQLStatementCancelledException.0")); + } + + public OperationCancelledException(String message) { + super(message); + } + + public OperationCancelledException(Throwable cause) { + super(cause); + } + + public OperationCancelledException(String message, Throwable cause) { + super(message, cause); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/PasswordExpiredException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/PasswordExpiredException.java new file mode 100644 index 0000000..28cc24e --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/PasswordExpiredException.java @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +/** + * Equivalent to SQLSTATE ER_MUST_CHANGE_PASSWORD = 1820 + * "You must SET PASSWORD before executing this statement" + * + * Server entered to sandbox morde when this failure happens. + */ +public class PasswordExpiredException extends CJException { + + private static final long serialVersionUID = -3807215681364413250L; + + public PasswordExpiredException() { + super(); + setVendorCode(MysqlErrorNumbers.ER_MUST_CHANGE_PASSWORD); + } + + public PasswordExpiredException(String message) { + super(message); + setVendorCode(MysqlErrorNumbers.ER_MUST_CHANGE_PASSWORD); + } + + public PasswordExpiredException(String message, Throwable cause) { + super(message, cause); + setVendorCode(MysqlErrorNumbers.ER_MUST_CHANGE_PASSWORD); + } + + public PasswordExpiredException(Throwable cause) { + super(cause); + setVendorCode(MysqlErrorNumbers.ER_MUST_CHANGE_PASSWORD); + } + + protected PasswordExpiredException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + setVendorCode(MysqlErrorNumbers.ER_MUST_CHANGE_PASSWORD); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/PropertyNotModifiableException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/PropertyNotModifiableException.java new file mode 100644 index 0000000..1ec42c0 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/PropertyNotModifiableException.java @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +public class PropertyNotModifiableException extends CJException { + + private static final long serialVersionUID = -8001652264426656450L; + + public PropertyNotModifiableException() { + super(); + } + + public PropertyNotModifiableException(String message) { + super(message); + } + + public PropertyNotModifiableException(String message, Throwable cause) { + super(message, cause); + } + + public PropertyNotModifiableException(Throwable cause) { + super(cause); + } + + protected PropertyNotModifiableException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/RSAException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/RSAException.java new file mode 100644 index 0000000..881f09b --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/RSAException.java @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +public class RSAException extends CJException { + + private static final long serialVersionUID = -1878681511263159173L; + + public RSAException() { + super(); + } + + public RSAException(String message) { + super(message); + } + + public RSAException(String message, Throwable cause) { + super(message, cause); + } + + public RSAException(Throwable cause) { + super(cause); + } + + protected RSAException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/SSLParamsException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/SSLParamsException.java new file mode 100644 index 0000000..8b4969e --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/SSLParamsException.java @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +public class SSLParamsException extends CJException { + + private static final long serialVersionUID = -6597843374954727858L; + + public SSLParamsException() { + super(); + setSQLState("08000"); + } + + public SSLParamsException(String message) { + super(message); + setSQLState("08000"); + } + + public SSLParamsException(String message, Throwable cause) { + super(message, cause); + setSQLState("08000"); + } + + public SSLParamsException(Throwable cause) { + super(cause); + setSQLState("08000"); + } + + public SSLParamsException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + setSQLState("08000"); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/StatementIsClosedException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/StatementIsClosedException.java new file mode 100644 index 0000000..038d9a8 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/StatementIsClosedException.java @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +/** + * Operation attempted on already closed Statement + */ +public class StatementIsClosedException extends CJException { + + private static final long serialVersionUID = -4214028635985851906L; + + public StatementIsClosedException() { + super(); + setSQLState("S1009"); + } + + public StatementIsClosedException(String message) { + super(message); + setSQLState("S1009"); + } + + public StatementIsClosedException(String message, Throwable cause) { + super(message, cause); + setSQLState("S1009"); + } + + public StatementIsClosedException(Throwable cause) { + super(cause); + setSQLState("S1009"); + } + + protected StatementIsClosedException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + setSQLState("S1009"); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/StreamingNotifiable.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/StreamingNotifiable.java new file mode 100644 index 0000000..d71fec1 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/StreamingNotifiable.java @@ -0,0 +1,36 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +public interface StreamingNotifiable { + + void setWasStreamingResults(); + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/UnableToConnectException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/UnableToConnectException.java new file mode 100644 index 0000000..92350bc --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/UnableToConnectException.java @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +public class UnableToConnectException extends CJException { + + private static final long serialVersionUID = 6824175447292574109L; + + public UnableToConnectException() { + super(); + setSQLState("08001"); + } + + public UnableToConnectException(String message) { + super(message); + setSQLState("08001"); + } + + public UnableToConnectException(String message, Throwable cause) { + super(message, cause); + setSQLState("08001"); + } + + public UnableToConnectException(Throwable cause) { + super(cause); + setSQLState("08001"); + } + + public UnableToConnectException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + setSQLState("08001"); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/UnsupportedConnectionStringException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/UnsupportedConnectionStringException.java new file mode 100644 index 0000000..e48a5c4 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/UnsupportedConnectionStringException.java @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2018, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +public class UnsupportedConnectionStringException extends CJException { + + private static final long serialVersionUID = 3991597077197801820L; + + public UnsupportedConnectionStringException() { + super(); + setSQLState(MysqlErrorNumbers.SQL_STATE_ILLEGAL_ARGUMENT); + } + + public UnsupportedConnectionStringException(String message) { + super(message); + setSQLState(MysqlErrorNumbers.SQL_STATE_ILLEGAL_ARGUMENT); + } + + public UnsupportedConnectionStringException(String message, Throwable cause) { + super(message, cause); + setSQLState(MysqlErrorNumbers.SQL_STATE_ILLEGAL_ARGUMENT); + } + + public UnsupportedConnectionStringException(Throwable cause) { + super(cause); + setSQLState(MysqlErrorNumbers.SQL_STATE_ILLEGAL_ARGUMENT); + } + + public UnsupportedConnectionStringException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + setSQLState(MysqlErrorNumbers.SQL_STATE_ILLEGAL_ARGUMENT); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/WrongArgumentException.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/WrongArgumentException.java new file mode 100644 index 0000000..6bad819 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/exceptions/WrongArgumentException.java @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.exceptions; + +public class WrongArgumentException extends CJException { + + private static final long serialVersionUID = 3991597077197801820L; + + public WrongArgumentException() { + super(); + setSQLState("S1009"); + } + + public WrongArgumentException(String message) { + super(message); + setSQLState("S1009"); + } + + public WrongArgumentException(String message, Throwable cause) { + super(message, cause); + setSQLState("S1009"); + } + + public WrongArgumentException(Throwable cause) { + super(cause); + setSQLState("S1009"); + } + + public WrongArgumentException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + setSQLState("S1009"); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/interceptors/QueryInterceptor.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/interceptors/QueryInterceptor.java new file mode 100644 index 0000000..ea404ad --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/interceptors/QueryInterceptor.java @@ -0,0 +1,181 @@ +/* + * Copyright (c) 2009, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.interceptors; + +import java.util.Properties; +import java.util.function.Supplier; + +import com.mysql.cj.MysqlConnection; +import com.mysql.cj.Query; +import com.mysql.cj.log.Log; +import com.mysql.cj.protocol.Message; +import com.mysql.cj.protocol.Resultset; +import com.mysql.cj.protocol.ServerSession; + +/** + * Implement this interface to be placed "in between" query execution, so that you can influence it. + * + * QueryInterceptors are "chainable" when configured by the user, the results returned by the "current" interceptor will be passed on to the next on in the + * chain, from left-to-right order, as specified by the user in the driver configuration property "queryInterceptors". + */ +public interface QueryInterceptor { + + /** + * Called once per connection that wants to use the interceptor + * + * The properties are the same ones passed in in the URL or arguments to + * Driver.connect() or DriverManager.getConnection(). + * + * @param conn + * the connection for which this interceptor is being created + * @param props + * configuration values as passed to the connection. Note that + * in order to support javax.sql.DataSources, configuration properties specific + * to an interceptor must be passed via setURL() on the + * DataSource. QueryInterceptor properties are not exposed via + * accessor/mutator methods on DataSources. + * @param log + * logger + * @return {@link QueryInterceptor} + */ + QueryInterceptor init(MysqlConnection conn, Properties props, Log log); + + /** + * Called before the given query is going to be sent to the server for processing. + * + * Interceptors are free to return a result set (which must implement the + * interface {@link Resultset}), and if so, + * the server will not execute the query, and the given result set will be + * returned to the application instead. + * + * This method will be called while the connection-level mutex is held, so + * it will only be called from one thread at a time. + * + * @param sql + * the Supplier for SQL representation of the query + * @param interceptedQuery + * the actual {@link Query} instance being intercepted + * @param + * {@link Resultset} object + * + * @return a {@link Resultset} that should be returned to the application instead + * of results that are created from actual execution of the intercepted + * query. + */ + T preProcess(Supplier sql, Query interceptedQuery); + + /** + * Called before the given query packet is going to be sent to the server for processing. + * + * Interceptors are free to return a PacketPayload, and if so, + * the server will not execute the query, and the given PacketPayload will be + * returned to the application instead. + * + * This method will be called while the connection-level mutex is held, so + * it will only be called from one thread at a time. + * + * @param queryPacket + * original {@link Message} + * @param + * {@link Message} object + * @return processed {@link Message} + */ + default M preProcess(M queryPacket) { + return null; + } + + /** + * Should the driver execute this interceptor only for the + * "original" top-level query, and not put it in the execution + * path for queries that may be executed from other interceptors? + * + * If an interceptor issues queries using the connection it was created for, + * and does not return true for this method, it must ensure + * that it does not cause infinite recursion. + * + * @return true if the driver should ensure that this interceptor is only + * executed for the top-level "original" query. + */ + boolean executeTopLevelOnly(); + + /** + * Called by the driver when this extension should release any resources + * it is holding and cleanup internally before the connection is + * closed. + */ + void destroy(); + + /** + * Called after the given query has been sent to the server for processing. + * + * Interceptors are free to inspect the "original" result set, and if a + * different result set is returned by the interceptor, it is used in place + * of the "original" result set. + * + * This method will be called while the connection-level mutex is held, so + * it will only be called from one thread at a time. + * + * @param sql + * the Supplier for SQL representation of the query + * @param interceptedQuery + * the actual {@link Query} instance being intercepted + * @param originalResultSet + * a {@link Resultset} created from query execution + * @param serverSession + * {@link ServerSession} object after the query execution + * @param + * {@link Resultset} object + * + * @return a {@link Resultset} that should be returned to the application instead + * of results that are created from actual execution of the intercepted + * query. + */ + T postProcess(Supplier sql, Query interceptedQuery, T originalResultSet, ServerSession serverSession); + + /** + * Called after the given query packet has been sent to the server for processing. + * + * Interceptors are free to return either a different PacketPayload than the originalResponsePacket or null. + * + * This method will be called while the connection-level mutex is held, so + * it will only be called from one thread at a time. + * + * @param queryPacket + * query {@link Message} + * @param originalResponsePacket + * response {@link Message} + * @param + * {@link Message} object + * @return {@link Message} + */ + default M postProcess(M queryPacket, M originalResponsePacket) { + return null; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/log/Jdk14Logger.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/log/Jdk14Logger.java new file mode 100644 index 0000000..bb5e49a --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/log/Jdk14Logger.java @@ -0,0 +1,274 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.log; + +import java.util.logging.Level; +import java.util.logging.Logger; + +/** + * Logging functionality for JDK1.4 + */ +public class Jdk14Logger implements Log { + private static final Level DEBUG = Level.FINE; + + private static final Level ERROR = Level.SEVERE; + + private static final Level FATAL = Level.SEVERE; + + private static final Level INFO = Level.INFO; + + private static final Level TRACE = Level.FINEST; + + private static final Level WARN = Level.WARNING; + + /** + * The underlying logger from JDK-1.4 + */ + protected Logger jdkLogger = null; + + /** + * Creates a new Jdk14Logger object. + * + * @param name + * logger name as per {@link Logger#getLogger(String)} + */ + public Jdk14Logger(String name) { + this.jdkLogger = Logger.getLogger(name); + } + + public boolean isDebugEnabled() { + return this.jdkLogger.isLoggable(Level.FINE); + } + + public boolean isErrorEnabled() { + return this.jdkLogger.isLoggable(Level.SEVERE); + } + + public boolean isFatalEnabled() { + return this.jdkLogger.isLoggable(Level.SEVERE); + } + + public boolean isInfoEnabled() { + return this.jdkLogger.isLoggable(Level.INFO); + } + + public boolean isTraceEnabled() { + return this.jdkLogger.isLoggable(Level.FINEST); + } + + public boolean isWarnEnabled() { + return this.jdkLogger.isLoggable(Level.WARNING); + } + + /** + * Logs the given message instance using the 'debug' level + * + * @param message + * the message to log + */ + public void logDebug(Object message) { + logInternal(DEBUG, message, null); + } + + /** + * Logs the given message and Throwable at the 'debug' level. + * + * @param message + * the message to log + * @param exception + * the throwable to log (may be null) + */ + public void logDebug(Object message, Throwable exception) { + logInternal(DEBUG, message, exception); + } + + /** + * Logs the given message instance using the 'error' level + * + * @param message + * the message to log + */ + public void logError(Object message) { + logInternal(ERROR, message, null); + } + + /** + * Logs the given message and Throwable at the 'error' level. + * + * @param message + * the message to log + * @param exception + * the throwable to log (may be null) + */ + public void logError(Object message, Throwable exception) { + logInternal(ERROR, message, exception); + } + + /** + * Logs the given message instance using the 'fatal' level + * + * @param message + * the message to log + */ + public void logFatal(Object message) { + logInternal(FATAL, message, null); + } + + /** + * Logs the given message and Throwable at the 'fatal' level. + * + * @param message + * the message to log + * @param exception + * the throwable to log (may be null) + */ + public void logFatal(Object message, Throwable exception) { + logInternal(FATAL, message, exception); + } + + /** + * Logs the given message instance using the 'info' level + * + * @param message + * the message to log + */ + public void logInfo(Object message) { + logInternal(INFO, message, null); + } + + /** + * Logs the given message and Throwable at the 'info' level. + * + * @param message + * the message to log + * @param exception + * the throwable to log (may be null) + */ + public void logInfo(Object message, Throwable exception) { + logInternal(INFO, message, exception); + } + + /** + * Logs the given message instance using the 'trace' level + * + * @param message + * the message to log + */ + public void logTrace(Object message) { + logInternal(TRACE, message, null); + } + + /** + * Logs the given message and Throwable at the 'trace' level. + * + * @param message + * the message to log + * @param exception + * the throwable to log (may be null) + */ + public void logTrace(Object message, Throwable exception) { + logInternal(TRACE, message, exception); + } + + /** + * Logs the given message instance using the 'warn' level + * + * @param message + * the message to log + */ + public void logWarn(Object message) { + logInternal(WARN, message, null); + } + + /** + * Logs the given message and Throwable at the 'warn' level. + * + * @param message + * the message to log + * @param exception + * the throwable to log (may be null) + */ + public void logWarn(Object message, Throwable exception) { + logInternal(WARN, message, exception); + } + + private static final int findCallerStackDepth(StackTraceElement[] stackTrace) { + int numFrames = stackTrace.length; + + for (int i = 0; i < numFrames; i++) { + String callerClassName = stackTrace[i].getClassName(); + + if (!(callerClassName.startsWith("com.mysql.cj") || callerClassName.startsWith("com.mysql.cj.core") + || callerClassName.startsWith("com.mysql.cj.jdbc"))) { + return i; + } + } + + return 0; + } + + private void logInternal(Level level, Object msg, Throwable exception) { + // + // only go through this exercise if the message will actually be logged. + // + + if (this.jdkLogger.isLoggable(level)) { + String messageAsString = null; + String callerMethodName = "N/A"; + String callerClassName = "N/A"; + //int lineNumber = 0; + //String fileName = "N/A"; + + if (msg instanceof ProfilerEvent) { + messageAsString = msg.toString(); + } else { + Throwable locationException = new Throwable(); + StackTraceElement[] locations = locationException.getStackTrace(); + + int frameIdx = findCallerStackDepth(locations); + + if (frameIdx != 0) { + callerClassName = locations[frameIdx].getClassName(); + callerMethodName = locations[frameIdx].getMethodName(); + //lineNumber = locations[frameIdx].getLineNumber(); + //fileName = locations[frameIdx].getFileName(); + } + + messageAsString = String.valueOf(msg); + } + + if (exception == null) { + this.jdkLogger.logp(level, callerClassName, callerMethodName, messageAsString); + } else { + this.jdkLogger.logp(level, callerClassName, callerMethodName, messageAsString, exception); + } + } + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/log/Log.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/log/Log.java new file mode 100644 index 0000000..905f6e2 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/log/Log.java @@ -0,0 +1,188 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.log; + +/** + * Unified interface to logging facilities on different platforms + */ +public interface Log { + /** Logger instance name */ + static final String LOGGER_INSTANCE_NAME = "MySQL"; + + /** + * Is the 'debug' log level enabled? + * + * @return true if so. + */ + boolean isDebugEnabled(); + + /** + * Is the 'error' log level enabled? + * + * @return true if so. + */ + boolean isErrorEnabled(); + + /** + * Is the 'fatal' log level enabled? + * + * @return true if so. + */ + boolean isFatalEnabled(); + + /** + * Is the 'info' log level enabled? + * + * @return true if so. + */ + boolean isInfoEnabled(); + + /** + * Is the 'trace' log level enabled? + * + * @return true if so. + */ + boolean isTraceEnabled(); + + /** + * Is the 'warn' log level enabled? + * + * @return true if so. + */ + boolean isWarnEnabled(); + + /** + * Logs the given message instance using the 'debug' level + * + * @param msg + * the message to log + */ + void logDebug(Object msg); + + /** + * Logs the given message and Throwable at the 'debug' level. + * + * @param msg + * the message to log + * @param thrown + * the throwable to log (may be null) + */ + void logDebug(Object msg, Throwable thrown); + + /** + * Logs the given message instance using the 'error' level + * + * @param msg + * the message to log + */ + void logError(Object msg); + + /** + * Logs the given message and Throwable at the 'error' level. + * + * @param msg + * the message to log + * @param thrown + * the throwable to log (may be null) + */ + void logError(Object msg, Throwable thrown); + + /** + * Logs the given message instance using the 'fatal' level + * + * @param msg + * the message to log + */ + void logFatal(Object msg); + + /** + * Logs the given message and Throwable at the 'fatal' level. + * + * @param msg + * the message to log + * @param thrown + * the throwable to log (may be null) + */ + void logFatal(Object msg, Throwable thrown); + + /** + * Logs the given message instance using the 'info' level + * + * @param msg + * the message to log + */ + void logInfo(Object msg); + + /** + * Logs the given message and Throwable at the 'info' level. + * + * @param msg + * the message to log + * @param thrown + * the throwable to log (may be null) + */ + void logInfo(Object msg, Throwable thrown); + + /** + * Logs the given message instance using the 'trace' level + * + * @param msg + * the message to log + */ + void logTrace(Object msg); + + /** + * Logs the given message and Throwable at the 'trace' level. + * + * @param msg + * the message to log + * @param thrown + * the throwable to log (may be null) + */ + void logTrace(Object msg, Throwable thrown); + + /** + * Logs the given message instance using the 'warn' level + * + * @param msg + * the message to log + */ + void logWarn(Object msg); + + /** + * Logs the given message and Throwable at the 'warn' level. + * + * @param msg + * the message to log + * @param thrown + * the throwable to log (may be null) + */ + void logWarn(Object msg, Throwable thrown); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/log/NullLogger.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/log/NullLogger.java new file mode 100644 index 0000000..95599f0 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/log/NullLogger.java @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.log; + +/** + * A logger that does nothing. Used before the log is configured via the URL or properties. + */ +public class NullLogger implements Log { + + /** + * Creates a new NullLogger with the given name + * + * @param instanceName + * (ignored) + */ + public NullLogger(String instanceName) { + } + + public boolean isDebugEnabled() { + return false; + } + + public boolean isErrorEnabled() { + return false; + } + + public boolean isFatalEnabled() { + return false; + } + + public boolean isInfoEnabled() { + return false; + } + + public boolean isTraceEnabled() { + return false; + } + + public boolean isWarnEnabled() { + return false; + } + + public void logDebug(Object msg) { + } + + public void logDebug(Object msg, Throwable thrown) { + } + + public void logError(Object msg) { + } + + public void logError(Object msg, Throwable thrown) { + } + + public void logFatal(Object msg) { + } + + public void logFatal(Object msg, Throwable thrown) { + } + + public void logInfo(Object msg) { + } + + public void logInfo(Object msg, Throwable thrown) { + } + + public void logTrace(Object msg) { + } + + public void logTrace(Object msg, Throwable thrown) { + } + + public void logWarn(Object msg) { + } + + public void logWarn(Object msg, Throwable thrown) { + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/log/ProfilerEvent.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/log/ProfilerEvent.java new file mode 100644 index 0000000..8a1162b --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/log/ProfilerEvent.java @@ -0,0 +1,157 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.log; + +public interface ProfilerEvent { + /** + * Profiler event for usage advisor + */ + public static final byte TYPE_USAGE = 0; + + /** + * Profiler creating object type event + */ + public static final byte TYPE_OBJECT_CREATION = 1; + + /** + * Profiler event for prepared statements being prepared + */ + public static final byte TYPE_PREPARE = 2; + + /** + * Profiler event for a query being executed + */ + public static final byte TYPE_QUERY = 3; + + /** + * Profiler event for prepared statements being executed + */ + public static final byte TYPE_EXECUTE = 4; + + /** + * Profiler event for result sets being retrieved + */ + public static final byte TYPE_FETCH = 5; + + /** + * Profiler event for slow query + */ + public static final byte TYPE_SLOW_QUERY = 6; + + /** + * Not available value. + */ + public static final byte NA = -1; + + /** + * Returns the event type + * + * @return the event type + */ + byte getEventType(); + + /** + * Returns the host name the event occurred on. + * + * @return host name + */ + String getHostName(); + + /** + * Returns the database the event occurred on. + * + * @return the database in use + */ + String getDatabase(); + + /** + * Returns the id of the associated connection (-1 for none). + * + * @return the connection in use + */ + long getConnectionId(); + + /** + * Returns the id of the associated statement (-1 for none). + * + * @return the statement in use + */ + int getStatementId(); + + /** + * Returns the id of the associated result set (-1 for none). + * + * @return the result set in use + */ + int getResultSetId(); + + /** + * Returns the time (in System.currentTimeMillis() form) when this event was created. + * + * @return the time this event was created + */ + long getEventCreationTime(); + + /** + * Returns the duration of the event in milliseconds + * + * @return the duration of the event in milliseconds + */ + long getEventDuration(); + + /** + * Returns the units for getEventDuration() + * + * @return name of duration units + */ + String getDurationUnits(); + + /** + * Returns the description of where the event was created. + * + * @return a description of where this event was created. + */ + String getEventCreationPointAsString(); + + /** + * Returns the optional message for this event + * + * @return the message stored in this event + */ + String getMessage(); + + /** + * Creates a binary representation of this event. + * + * @return a binary representation of this event + */ + byte[] pack(); + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/log/ProfilerEventHandler.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/log/ProfilerEventHandler.java new file mode 100644 index 0000000..a6b4ef6 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/log/ProfilerEventHandler.java @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2007, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.log; + +import com.mysql.cj.Query; +import com.mysql.cj.Session; +import com.mysql.cj.protocol.Resultset; + +public interface ProfilerEventHandler { + + void init(Log log); + + void destroy(); + + void consumeEvent(ProfilerEvent evt); + + void processEvent(byte eventType, Session session, Query query, Resultset resultSet, long eventDuration, Throwable eventCreationPoint, String message); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/log/Slf4JLogger.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/log/Slf4JLogger.java new file mode 100644 index 0000000..f80391c --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/log/Slf4JLogger.java @@ -0,0 +1,114 @@ +/* + * Copyright (c) 2011, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.log; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class Slf4JLogger implements Log { + private Logger log; + + public Slf4JLogger(String name) { + this.log = LoggerFactory.getLogger(name); + } + + public boolean isDebugEnabled() { + return this.log.isDebugEnabled(); + } + + public boolean isErrorEnabled() { + return this.log.isErrorEnabled(); + } + + public boolean isFatalEnabled() { + return this.log.isErrorEnabled(); + } + + public boolean isInfoEnabled() { + return this.log.isInfoEnabled(); + } + + public boolean isTraceEnabled() { + return this.log.isTraceEnabled(); + } + + public boolean isWarnEnabled() { + return this.log.isWarnEnabled(); + } + + public void logDebug(Object msg) { + this.log.debug(msg.toString()); + } + + public void logDebug(Object msg, Throwable thrown) { + this.log.debug(msg.toString(), thrown); + } + + public void logError(Object msg) { + this.log.error(msg.toString()); + } + + public void logError(Object msg, Throwable thrown) { + this.log.error(msg.toString(), thrown); + } + + public void logFatal(Object msg) { + this.log.error(msg.toString()); + } + + public void logFatal(Object msg, Throwable thrown) { + this.log.error(msg.toString(), thrown); + } + + public void logInfo(Object msg) { + this.log.info(msg.toString()); + } + + public void logInfo(Object msg, Throwable thrown) { + this.log.info(msg.toString(), thrown); + } + + public void logTrace(Object msg) { + this.log.trace(msg.toString()); + } + + public void logTrace(Object msg, Throwable thrown) { + this.log.trace(msg.toString(), thrown); + } + + public void logWarn(Object msg) { + this.log.warn(msg.toString()); + } + + public void logWarn(Object msg, Throwable thrown) { + this.log.warn(msg.toString(), thrown); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/log/StandardLogger.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/log/StandardLogger.java new file mode 100644 index 0000000..14c546c --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/log/StandardLogger.java @@ -0,0 +1,298 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.log; + +import java.util.Date; + +import com.mysql.cj.util.LogUtils; +import com.mysql.cj.util.Util; + +/** + * Provides logging facilities for those platforms that don't have built-in facilities. Simply logs messages to STDERR. + */ +public class StandardLogger implements Log { + private static final int FATAL = 0; + + private static final int ERROR = 1; + + private static final int WARN = 2; + + private static final int INFO = 3; + + private static final int DEBUG = 4; + + private static final int TRACE = 5; + + private boolean logLocationInfo = true; + + /** + * Creates a new StandardLogger object. + * + * @param name + * the name of the configuration to use -- ignored + */ + public StandardLogger(String name) { + this(name, false); + } + + /** + * @param name + * the name of the configuration to use -- ignored + * @param logLocationInfo + * logLocationInfo + */ + public StandardLogger(String name, boolean logLocationInfo) { + this.logLocationInfo = logLocationInfo; + } + + public boolean isDebugEnabled() { + return true; + } + + public boolean isErrorEnabled() { + return true; + } + + public boolean isFatalEnabled() { + return true; + } + + public boolean isInfoEnabled() { + return true; + } + + public boolean isTraceEnabled() { + return true; + } + + public boolean isWarnEnabled() { + return true; + } + + /** + * Logs the given message instance using the 'debug' level + * + * @param message + * the message to log + */ + public void logDebug(Object message) { + logInternal(DEBUG, message, null); + } + + /** + * Logs the given message and Throwable at the 'debug' level. + * + * @param message + * the message to log + * @param exception + * the throwable to log (may be null) + */ + public void logDebug(Object message, Throwable exception) { + logInternal(DEBUG, message, exception); + } + + /** + * Logs the given message instance using the 'error' level + * + * @param message + * the message to log + */ + public void logError(Object message) { + logInternal(ERROR, message, null); + } + + /** + * Logs the given message and Throwable at the 'error' level. + * + * @param message + * the message to log + * @param exception + * the throwable to log (may be null) + */ + public void logError(Object message, Throwable exception) { + logInternal(ERROR, message, exception); + } + + /** + * Logs the given message instance using the 'fatal' level + * + * @param message + * the message to log + */ + public void logFatal(Object message) { + logInternal(FATAL, message, null); + } + + /** + * Logs the given message and Throwable at the 'fatal' level. + * + * @param message + * the message to log + * @param exception + * the throwable to log (may be null) + */ + public void logFatal(Object message, Throwable exception) { + logInternal(FATAL, message, exception); + } + + /** + * Logs the given message instance using the 'info' level + * + * @param message + * the message to log + */ + public void logInfo(Object message) { + logInternal(INFO, message, null); + } + + /** + * Logs the given message and Throwable at the 'info' level. + * + * @param message + * the message to log + * @param exception + * the throwable to log (may be null) + */ + public void logInfo(Object message, Throwable exception) { + logInternal(INFO, message, exception); + } + + /** + * Logs the given message instance using the 'trace' level + * + * @param message + * the message to log + */ + public void logTrace(Object message) { + logInternal(TRACE, message, null); + } + + /** + * Logs the given message and Throwable at the 'trace' level. + * + * @param message + * the message to log + * @param exception + * the throwable to log (may be null) + */ + public void logTrace(Object message, Throwable exception) { + logInternal(TRACE, message, exception); + } + + /** + * Logs the given message instance using the 'warn' level + * + * @param message + * the message to log + */ + public void logWarn(Object message) { + logInternal(WARN, message, null); + } + + /** + * Logs the given message and Throwable at the 'warn' level. + * + * @param message + * the message to log + * @param exception + * the throwable to log (may be null) + */ + public void logWarn(Object message, Throwable exception) { + logInternal(WARN, message, exception); + } + + protected String logInternal(int level, Object msg, Throwable exception) { + StringBuilder msgBuf = new StringBuilder(); + msgBuf.append(new Date().toString()); + msgBuf.append(" "); + + switch (level) { + case FATAL: + msgBuf.append("FATAL: "); + + break; + + case ERROR: + msgBuf.append("ERROR: "); + + break; + + case WARN: + msgBuf.append("WARN: "); + + break; + + case INFO: + msgBuf.append("INFO: "); + + break; + + case DEBUG: + msgBuf.append("DEBUG: "); + + break; + + case TRACE: + msgBuf.append("TRACE: "); + + break; + } + + if (msg instanceof ProfilerEvent) { + msgBuf.append(msg.toString()); + + } else { + if (this.logLocationInfo && level != TRACE) { + Throwable locationException = new Throwable(); + msgBuf.append(LogUtils.findCallingClassAndMethod(locationException)); + msgBuf.append(" "); + } + + if (msg != null) { + msgBuf.append(String.valueOf(msg)); + } + } + + if (exception != null) { + msgBuf.append("\n"); + msgBuf.append("\n"); + msgBuf.append("EXCEPTION STACK TRACE:"); + msgBuf.append("\n"); + msgBuf.append("\n"); + msgBuf.append(Util.stackTraceToString(exception)); + } + + String messageAsString = msgBuf.toString(); + + System.err.println(messageAsString); + + return messageAsString; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/AuthenticationPlugin.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/AuthenticationPlugin.java new file mode 100644 index 0000000..767e976 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/AuthenticationPlugin.java @@ -0,0 +1,154 @@ +/* + * Copyright (c) 2012, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.util.List; + +import com.mysql.cj.callback.MysqlCallbackHandler; + +/** + * Implementors of this interface can be installed via the "authenticationPlugins" configuration property. + * + * The driver will create one instance of a given plugin per AuthenticationProvider instance if it's reusable (see {@link #isReusable()}) or a new instance + * in each NativeAuthenticationProvider#proceedHandshakeWithPluggableAuthentication(String, String, String, Buffer) call. + * + * @param + * Message type + */ +public interface AuthenticationPlugin { + + /** + * We need direct Protocol reference because it isn't available from Connection before authentication complete. + * + * @param protocol + * protocol instance + */ + default void init(Protocol protocol) { + } + + /** + * Initializes this plugin with a direct Protocol reference and a generic {@link MysqlCallbackHandler} that can be used to pass over information back to the + * authentication provider. + * For example an authentication plugin may accept null usernames and use that information to obtain them from some external source, such as + * the system login. + * + * @param protocol + * the protocol instance + * @param callbackHandler + * a callback handler to provide additional information to the authentication provider + */ + default void init(Protocol protocol, MysqlCallbackHandler callbackHandler) { + init(protocol); + } + + /** + * Resets the authentication steps sequence. + */ + default void reset() { + } + + /** + * Called by the driver when this extension should release any resources it is holding and cleanup internally before the connection is closed. + */ + default void destroy() { + } + + /** + * Returns the client-side name that the MySQL server uses on the wire for this plugin. + * + * @return plugin name + */ + String getProtocolPluginName(); + + /** + * Does this plugin require the connection itself to be confidential (i.e. tls/ssl)...Highly recommended to return "true" for plugins that return the + * credentials in the clear. + * + * @return true if secure connection is required + */ + boolean requiresConfidentiality(); + + /** + * @return true if plugin instance may be reused, false otherwise + */ + boolean isReusable(); + + /** + * This method called from Connector/J before first nextAuthenticationStep call. Values of user and password parameters are passed from those in + * NativeAuthenticationProvider#changeUser() or NativeAuthenticationProvider#connect(). + * + * Plugin should use these values instead of values from connection properties because parent method may be a changeUser call which saves user and password + * into connection only after successful handshake. + * + * @param user + * user name + * @param password + * user password + */ + void setAuthenticationParameters(String user, String password); + + /** + * Connector/J uses this method to identify the source of the authentication data, as an authentication plugin name, that will be available to the next + * authentication step(s). The source of the authentication data in the first iteration will always be the sever-side default authentication plugin name. + * In the following iterations this depends on the client-side default authentication plugin or on the successive Protocol::AuthSwitchRequest that may have + * been received in the meantime. + * + * Authentication plugin implementation can use this information to decide if the data coming from the server is useful to them or not. + * + * @param sourceOfAuthData + */ + default void setSourceOfAuthData(String sourceOfAuthData) { + // Do nothing by default. + } + + /** + * Process authentication handshake data from server and optionally produce data to be sent back to the server. + * The driver will keep calling this method on each new server packet arrival until either an Exception is thrown + * (authentication failure, please use appropriate SQLStates) or the number of exchange iterations exceeded max + * limit or an OK packet is sent by server indicating that the connection has been approved. + * + * If, on return from this method, toServer is a non-empty list of buffers, then these buffers will be sent to + * the server in the same order and without any reads in between them. If toServer is an empty list, no + * data will be sent to server, driver immediately reads the next packet from server. + * + * In case of errors the method should throw Exception. + * + * @param fromServer + * a buffer containing handshake data payload from + * server (can be empty). + * @param toServer + * list of buffers with data to be sent to the server + * (the list can be empty, but buffers in the list + * should contain data). + * + * @return return value is ignored. + */ + boolean nextAuthenticationStep(M fromServer, List toServer); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/AuthenticationProvider.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/AuthenticationProvider.java new file mode 100644 index 0000000..b841480 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/AuthenticationProvider.java @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2015, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.ExceptionInterceptor; + +public interface AuthenticationProvider { + + void init(Protocol prot, PropertySet propertySet, ExceptionInterceptor exceptionInterceptor); + + void connect(String username, String password, String database); + + /** + * Re-authenticates as the given user and password + * + * @param username + * user name + * @param password + * password + * @param database + * db name + */ + void changeUser(String username, String password, String database); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ColumnDefinition.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ColumnDefinition.java new file mode 100644 index 0000000..6f22a17 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ColumnDefinition.java @@ -0,0 +1,85 @@ +/* + * Copyright (c) 2016, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.util.Map; + +import com.mysql.cj.result.Field; + +/** + * Represents protocol specific result set metadata, + * eg., for native protocol, Protocol::ColumnDefinition41 protocol entity. + * + */ +public interface ColumnDefinition extends ProtocolEntity { + + Field[] getFields(); + + void setFields(Field[] fields); + + /** + * Builds a hash between column names and their indices for fast retrieval. + * This is done lazily to support findColumn() and get*(String), as it + * can be more expensive than just retrieving result set values by ordinal + * index. + */ + void buildIndexMapping(); + + boolean hasBuiltIndexMapping(); + + public Map getColumnLabelToIndex(); + + void setColumnLabelToIndex(Map columnLabelToIndex); + + public Map getFullColumnNameToIndex(); + + void setFullColumnNameToIndex(Map fullColNameToIndex); + + public Map getColumnNameToIndex(); + + void setColumnNameToIndex(Map colNameToIndex); + + public Map getColumnToIndexCache(); + + public void setColumnToIndexCache(Map columnToIndexCache); + + void initializeFrom(ColumnDefinition columnDefinition); + + void exportTo(ColumnDefinition columnDefinition); + + int findColumn(String columnName, boolean useColumnNamesInFindColumn, int indexBase); + + /** + * Check if fields with type BLOB, MEDIUMBLOB, LONGBLOB, TEXT, MEDIUMTEXT or LONGTEXT exist in this ColumnDefinition. + * + * @return true if fields with type BLOB, MEDIUMBLOB, LONGBLOB, TEXT, MEDIUMTEXT or LONGTEXT exist in this ColumnDefinition. + */ + boolean hasLargeFields(); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/FullReadInputStream.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/FullReadInputStream.java new file mode 100644 index 0000000..cdeb672 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/FullReadInputStream.java @@ -0,0 +1,113 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.io.EOFException; +import java.io.FilterInputStream; +import java.io.IOException; +import java.io.InputStream; + +import com.mysql.cj.Messages; + +/** + * InputStream wrapper that provides methods to aggregate reads of a given size. c.f. readFully(byte[],int,int). + */ +public class FullReadInputStream extends FilterInputStream { + + public FullReadInputStream(InputStream underlyingStream) { + super(underlyingStream); + } + + public InputStream getUnderlyingStream() { + return this.in; + } + + public int readFully(byte[] b) throws IOException { + return readFully(b, 0, b.length); + } + + public int readFully(byte[] b, int off, int len) throws IOException { + if (len < 0) { + throw new IndexOutOfBoundsException(); + } + + int n = 0; + + while (n < len) { + int count = read(b, off + n, len - n); + + if (count < 0) { + throw new EOFException(Messages.getString("MysqlIO.EOF", new Object[] { Integer.valueOf(len), Integer.valueOf(n) })); + } + + n += count; + } + + return n; + } + + public long skipFully(long len) throws IOException { + if (len < 0) { + throw new IOException(Messages.getString("MysqlIO.105")); + } + + long n = 0; + + while (n < len) { + long count = skip(len - n); + + if (count < 0) { + throw new EOFException(Messages.getString("MysqlIO.EOF", new Object[] { Long.valueOf(len), Long.valueOf(n) })); + } + + n += count; + } + + return n; + } + + public int skipLengthEncodedInteger() throws IOException { + int sw = read() & 0xff; + + switch (sw) { + case 252: + return (int) skipFully(2) + 1; + + case 253: + return (int) skipFully(3) + 1; + + case 254: + return (int) skipFully(8) + 1; + + default: + return 1; + } + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/InternalDate.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/InternalDate.java new file mode 100644 index 0000000..bf5e6dd --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/InternalDate.java @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2019, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +public class InternalDate { + + protected int year = 0; + protected int month = 0; + protected int day = 0; + + /** + * Constructs a zero date. + */ + public InternalDate() { + } + + public InternalDate(int year, int month, int day) { + this.year = year; + this.month = month; + this.day = day; + } + + public int getYear() { + return this.year; + } + + public void setYear(int year) { + this.year = year; + } + + public int getMonth() { + return this.month; + } + + public void setMonth(int month) { + this.month = month; + } + + public int getDay() { + return this.day; + } + + public void setDay(int day) { + this.day = day; + } + + public boolean isZero() { + return this.year == 0 && this.month == 0 && this.day == 0; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/InternalTime.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/InternalTime.java new file mode 100644 index 0000000..4fec6c1 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/InternalTime.java @@ -0,0 +1,116 @@ +/* + * Copyright (c) 2019, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import com.mysql.cj.util.TimeUtil; + +public class InternalTime { + + private boolean negative = false; + private int hours = 0; + private int minutes = 0; + private int seconds = 0; + private int nanos = 0; + private int scale = 0; + + /** + * Constructs a zero time + */ + public InternalTime() { + } + + public InternalTime(int hours, int minutes, int seconds, int nanos, int scale) { + this.hours = hours; + this.minutes = minutes; + this.seconds = seconds; + this.nanos = nanos; + this.scale = scale; + } + + public boolean isNegative() { + return this.negative; + } + + public void setNegative(boolean negative) { + this.negative = negative; + } + + public int getHours() { + return this.hours; + } + + public void setHours(int hours) { + this.hours = hours; + } + + public int getMinutes() { + return this.minutes; + } + + public void setMinutes(int minutes) { + this.minutes = minutes; + } + + public int getSeconds() { + return this.seconds; + } + + public void setSeconds(int seconds) { + this.seconds = seconds; + } + + public int getNanos() { + return this.nanos; + } + + public void setNanos(int nanos) { + this.nanos = nanos; + } + + public boolean isZero() { + return this.hours == 0 && this.minutes == 0 && this.seconds == 0 && this.nanos == 0; + } + + public int getScale() { + return this.scale; + } + + public void setScale(int scale) { + this.scale = scale; + } + + @Override + public String toString() { + if (this.nanos > 0) { + return String.format("%02d:%02d:%02d.%s", this.hours, this.minutes, this.seconds, TimeUtil.formatNanos(this.nanos, this.scale, false)); + } + return String.format("%02d:%02d:%02d", this.hours, this.minutes, this.seconds); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/InternalTimestamp.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/InternalTimestamp.java new file mode 100644 index 0000000..e5bd0a3 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/InternalTimestamp.java @@ -0,0 +1,111 @@ +/* + * Copyright (c) 2019, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +public class InternalTimestamp extends InternalDate { + + private int hours = 0; + private int minutes = 0; + private int seconds = 0; + private int nanos = 0; + private int scale = 0; + private int offset = 0; + + /** + * Constructs a zero datetime + */ + public InternalTimestamp() { + super(); + } + + public InternalTimestamp(int year, int month, int day, int hours, int minutes, int seconds, int nanos, int scale) { + this.year = year; + this.month = month; + this.day = day; + this.hours = hours; + this.minutes = minutes; + this.seconds = seconds; + this.nanos = nanos; + this.scale = scale; + } + + public int getHours() { + return this.hours; + } + + public void setHours(int hours) { + this.hours = hours; + } + + public int getMinutes() { + return this.minutes; + } + + public void setMinutes(int minutes) { + this.minutes = minutes; + } + + public int getSeconds() { + return this.seconds; + } + + public void setSeconds(int seconds) { + this.seconds = seconds; + } + + public int getNanos() { + return this.nanos; + } + + public void setNanos(int nanos) { + this.nanos = nanos; + } + + public int getScale() { + return this.scale; + } + + public void setScale(int scale) { + this.scale = scale; + } + + public int getOffset() { + return this.offset; + } + + public void setOffset(int offset) { + this.offset = offset; + } + + @Override + public boolean isZero() { + return super.isZero() && this.hours == 0 && this.minutes == 0 && this.seconds == 0 && this.nanos == 0; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/Message.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/Message.java new file mode 100644 index 0000000..069f958 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/Message.java @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2018, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +/** + * Message is the content of a full single message (native protocol packet or protobuf message), + * independent from on-wire splitting, communicated with the server. + */ +public interface Message { + + /** + * Returns the array of bytes this Buffer is using to read from. + * + * @return byte array being read from + */ + byte[] getByteBuffer(); + + /** + * Returns the current position to write to/ read from + * + * @return the current position to write to/ read from + */ + int getPosition(); + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/MessageHeader.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/MessageHeader.java new file mode 100644 index 0000000..a2fe5d0 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/MessageHeader.java @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2018, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.nio.ByteBuffer; + +/** + * Represents the protocol specific message header + */ +public interface MessageHeader { + + ByteBuffer getBuffer(); + + int getMessageSize(); + + byte getMessageSequence(); + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/MessageListener.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/MessageListener.java new file mode 100644 index 0000000..d59b42d --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/MessageListener.java @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2016, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import com.mysql.cj.exceptions.CJOperationNotSupportedException; +import com.mysql.cj.exceptions.ExceptionFactory; + +/** + * Sink for messages that are read asynchonously from the socket. + * + * Return whether the listener is done receiving messages. + * + * @param + * Message type + */ +public interface MessageListener { + + /** + * Process protocol message. + * + * @param message + * {@link Message} instance + * @return true - if this listener is done with processing the messages sequence and may be discarded; + * false - if the next message must be dispatched to the same listener + */ + default boolean processMessage(M message) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not allowed"); + } + + /** + * Exceptionally complete underlying Future. + * + * @param ex + * exception to pass to underlying Future. + */ + void error(Throwable ex); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/MessageReader.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/MessageReader.java new file mode 100644 index 0000000..3847099 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/MessageReader.java @@ -0,0 +1,140 @@ +/* + * Copyright (c) 2018, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.io.IOException; +import java.util.Optional; + +import com.mysql.cj.exceptions.CJOperationNotSupportedException; +import com.mysql.cj.exceptions.ExceptionFactory; + +public interface MessageReader { + + /** + * Read the next message header from server, possibly blocking indefinitely until the message is received. + * + * @return {@link MessageHeader} of the next message + * @throws IOException + * if an error occurs + */ + H readHeader() throws IOException; + + /** + * Read message from server into to the given {@link Message} instance or into the new one if not present. + * For asynchronous channel it synchronously reads the next message in the stream, blocking until the message is read fully. + * Could throw CJCommunicationsException wrapping an {@link IOException} during read or parse + * + * @param reuse + * {@link Message} object to reuse. May be ignored by implementation. + * @param header + * {@link MessageHeader} instance + * @return {@link Message} instance + * @throws IOException + * if an error occurs + */ + M readMessage(Optional reuse, H header) throws IOException; + + /** + * Read message from server into to the given {@link Message} instance or into the new one if not present. + * For asynchronous channel it synchronously reads the next message in the stream, blocking until the message is read fully. + * Could throw WrongArgumentException if the expected message type is not the next message (exception will be thrown in *caller* context). + * + * @param reuse + * {@link Message} object to reuse. May be ignored by implementation. + * @param expectedType + * Expected type of message. + * @return {@link Message} instance + * @throws IOException + * if an error occurs + */ + default M readMessage(Optional reuse, int expectedType) throws IOException { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not supported"); + } + + /** + * Queue a {@link MessageListener} to receive messages delivered asynchronously. + * + * @param l + * {@link MessageListener} + */ + default void pushMessageListener(MessageListener l) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not supported"); + } + + /** + * Get last message sequence number, as it was stored by {@link #readHeader()}. + * + * @return number + */ + default byte getMessageSequence() { + return 0; + } + + /** + * Set stored message sequence number to 0. + */ + default void resetMessageSequence() { + // no-op + } + + /** + * Return a MessageReader instance free of decorators. + * + * @return {@link MessageReader} + */ + default MessageReader undecorateAll() { + return this; + } + + /** + * Return the previous MessageReader instance from the decorators chain or the current MessageReader + * if it is the first entry in a chain. + * + * @return {@link MessageReader} + */ + default MessageReader undecorate() { + return this; + } + + /** + * Start reading messages reader from the provided channel. + */ + default void start() { + // no-op + } + + /** + * Signal to the reader that it should stop reading messages after reading the next message. + */ + default void stopAfterNextMessage() { + // no-op + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/MessageSender.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/MessageSender.java new file mode 100644 index 0000000..a28ff09 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/MessageSender.java @@ -0,0 +1,117 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.io.IOException; +import java.util.concurrent.CompletableFuture; + +import com.mysql.cj.exceptions.CJOperationNotSupportedException; +import com.mysql.cj.exceptions.ExceptionFactory; + +/** + * This interface provides a facility for sending messages to server. The destination, transmission method, etc are determined by the implementation. + * + * @param + * Message type + */ +public interface MessageSender { + + /** + * Synchronously send the message to server. + * + * @param message + * byte array containing a message + * @param messageLen + * length of the message + * @param messageSequence + * message sequence index (used in a native protocol) + * @throws IOException + * if an error occurs + */ + default void send(byte[] message, int messageLen, byte messageSequence) throws IOException { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not supported"); + } + + /** + * Synchronously send the message to server. + * + * @param message + * {@link Message} instance + */ + default void send(M message) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not supported"); + } + + /** + * Asynchronously write a message with a notification being delivered to callback upon completion of write of entire message. + * + * @param message + * message extending {@link Message} + * @param future + * a Future returning operation result + * @param callback + * a callback to receive notification of when the message is completely written + * @return result + */ + default CompletableFuture send(M message, CompletableFuture future, Runnable callback) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not supported"); + } + + /** + * Set max allowed packet size. + * + * @param maxAllowedPacket + * max allowed packet size + */ + default void setMaxAllowedPacket(int maxAllowedPacket) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not supported"); + } + + /** + * Return a PacketSender instance free of decorators. + * + * @return + * {@link MessageSender} instance + */ + default MessageSender undecorateAll() { + return this; + } + + /** + * Return the previous PacketSender instance from the decorators chain or the current PacketSender + * if it is the first entry in a chain. + * + * @return + * {@link MessageSender} instance + */ + default MessageSender undecorate() { + return this; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/NetworkResources.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/NetworkResources.java new file mode 100644 index 0000000..469649b --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/NetworkResources.java @@ -0,0 +1,100 @@ +/* + * Copyright (c) 2012, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.net.Socket; + +public class NetworkResources { + private final Socket mysqlConnection; + private final InputStream mysqlInput; + private final OutputStream mysqlOutput; + + public NetworkResources(Socket mysqlConnection, InputStream mysqlInput, OutputStream mysqlOutput) { + this.mysqlConnection = mysqlConnection; + this.mysqlInput = mysqlInput; + this.mysqlOutput = mysqlOutput; + } + + /** + * Forcibly closes the underlying socket to MySQL. + */ + public final void forceClose() { + try { + if (!ExportControlled.isSSLEstablished(this.mysqlConnection)) { // Fix for Bug#56979 does not apply to secure sockets. + try { + if (this.mysqlInput != null) { + this.mysqlInput.close(); + } + } finally { + if (this.mysqlConnection != null && !this.mysqlConnection.isClosed() && !this.mysqlConnection.isInputShutdown()) { + try { + this.mysqlConnection.shutdownInput(); + } catch (UnsupportedOperationException e) { + // Ignore, some sockets do not support this method. + } + } + } + } + } catch (IOException e) { + // Can't do anything constructive about this. + } + + try { + if (!ExportControlled.isSSLEstablished(this.mysqlConnection)) { // Fix for Bug#56979 does not apply to secure sockets. + try { + if (this.mysqlOutput != null) { + this.mysqlOutput.close(); + } + } finally { + if (this.mysqlConnection != null && !this.mysqlConnection.isClosed() && !this.mysqlConnection.isOutputShutdown()) { + try { + this.mysqlConnection.shutdownOutput(); + } catch (UnsupportedOperationException e) { + // Ignore, some sockets do not support this method. + } + } + } + } + } catch (IOException e) { + // Can't do anything constructive about this. + } + + try { + if (this.mysqlConnection != null) { + this.mysqlConnection.close(); + } + } catch (IOException e) { + // Can't do anything constructive about this. + } + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/OutputStreamWatcher.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/OutputStreamWatcher.java new file mode 100644 index 0000000..fbb6ac2 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/OutputStreamWatcher.java @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +/** + * Objects that want to be notified of lifecycle events on a WatchableOutputStream should implement this interface, and register themselves with setWatcher() + * on the WatchableOutputStream instance. + */ +public interface OutputStreamWatcher { + /** + * Called when the OutputStream being watched has .close() called + * + * @param out + * {@link WatchableStream} + */ + void streamClosed(WatchableStream out); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/PacketReceivedTimeHolder.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/PacketReceivedTimeHolder.java new file mode 100644 index 0000000..995be98 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/PacketReceivedTimeHolder.java @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2016, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +/** + * Holds the time the last packet was received. + */ +public interface PacketReceivedTimeHolder { + default long getLastPacketReceivedTime() { + return 0; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/PacketSentTimeHolder.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/PacketSentTimeHolder.java new file mode 100644 index 0000000..a59fbd5 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/PacketSentTimeHolder.java @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +/** + * Holds the time the last packet was sent. + */ +public interface PacketSentTimeHolder { + + /** + * Returns the send time of a very recent packet. + * Should be used in exception generation when the send operation failed. + * + * @return very recent packet send time + */ + default long getLastPacketSentTime() { + return 0; + } + + /** + * Returns the send time of a previous packet. + * Should be used in exception generation when the send operation was successful + * but the following read operation failed. + * + * @return previous packet send time + */ + default long getPreviousPacketSentTime() { + return 0; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/Protocol.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/Protocol.java new file mode 100644 index 0000000..6019799 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/Protocol.java @@ -0,0 +1,312 @@ +/* + * Copyright (c) 2015, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.io.IOException; +import java.io.InputStream; + +import com.mysql.cj.MessageBuilder; +import com.mysql.cj.QueryResult; +import com.mysql.cj.Session; +import com.mysql.cj.TransactionEventHandler; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.CJException; +import com.mysql.cj.exceptions.ExceptionInterceptor; +import com.mysql.cj.protocol.Protocol.ProtocolEventListener.EventType; + +/** + * A protocol provides the facilities to communicate with a MySQL server. + * + * @param + * Message type + */ +public interface Protocol { + + /** + * Init method takes the place of constructor. + * + * A constructor should be used unless the encapsulation of ProtocolFactory is necessary. + * + * @param session + * {@link Session} + * @param socketConnection + * {@link SocketConnection} + * @param propertySet + * {@link PropertySet} + * @param transactionManager + * {@link TransactionEventHandler} + */ + void init(Session session, SocketConnection socketConnection, PropertySet propertySet, TransactionEventHandler transactionManager); + + PropertySet getPropertySet(); + + void setPropertySet(PropertySet propertySet); + + MessageBuilder getMessageBuilder(); + + /** + * Retrieve ServerCapabilities from server. + * + * @return {@link ServerCapabilities} + */ + ServerCapabilities readServerCapabilities(); + + ServerSession getServerSession(); + + SocketConnection getSocketConnection(); + + AuthenticationProvider getAuthenticationProvider(); + + ExceptionInterceptor getExceptionInterceptor(); + + PacketSentTimeHolder getPacketSentTimeHolder(); + + void setPacketSentTimeHolder(PacketSentTimeHolder packetSentTimeHolder); + + PacketReceivedTimeHolder getPacketReceivedTimeHolder(); + + void setPacketReceivedTimeHolder(PacketReceivedTimeHolder packetReceivedTimeHolder); + + /** + * Create a new session. This generally happens once at the beginning of a connection. + * + * @param user + * DB user name + * @param password + * DB user password + * @param database + * database name + */ + void connect(String user, String password, String database); + + void negotiateSSLConnection(); + + void beforeHandshake(); + + void afterHandshake(); + + void changeDatabase(String database); + + /** + * Re-authenticates as the given user and password + * + * @param user + * DB user name + * @param password + * DB user password + * @param database + * database name + * + */ + void changeUser(String user, String password, String database); + + boolean versionMeetsMinimum(int major, int minor, int subminor); + + /** + * Read one message from the MySQL server into the reusable buffer if provided or into the new one. + * + * @param reuse + * {@link Message} instance to read into, may be null + * @return the message from the server. + */ + M readMessage(M reuse); + + /** + * Read one message from the MySQL server, checks for errors in it, and if none, + * returns the message, ready for reading + * + * @return a message ready for reading. + */ + M checkErrorMessage(); + + /** + * @param message + * {@link Message} instance + * @param packetLen + * length of header + payload + */ + void send(Message message, int packetLen); + + ColumnDefinition readMetadata(); + + /** + * Send a command to the MySQL server. + * + * @param queryPacket + * a packet pre-loaded with data for the protocol (eg. + * from a client-side prepared statement). The first byte of + * this packet is the MySQL protocol 'command' from MysqlDefs + * @param skipCheck + * do not call checkErrorPacket() if true + * @param timeoutMillis + * timeout + * + * @return the response packet from the server + * + * @throws CJException + * if an I/O error or SQL error occurs + */ + + M sendCommand(Message queryPacket, boolean skipCheck, int timeoutMillis); + + T read(Class requiredClass, ProtocolEntityFactory protocolEntityFactory) throws IOException; + + /** + * Read protocol entity. + * + * @param requiredClass + * required Resultset class + * @param maxRows + * the maximum number of rows to read (-1 means all rows) + * @param streamResults + * should the driver leave the results on the wire, + * and read them only when needed? + * @param resultPacket + * the first packet of information in the result set + * @param isBinaryEncoded + * true if the binary protocol is used (for server prepared statements) + * @param metadata + * use this metadata instead of the one provided on wire + * @param protocolEntityFactory + * {@link ProtocolEntityFactory} instance + * @param + * object extending the {@link ProtocolEntity} + * @return + * {@link ProtocolEntity} instance + * @throws IOException + * if an error occurs + */ + T read(Class requiredClass, int maxRows, boolean streamResults, M resultPacket, boolean isBinaryEncoded, + ColumnDefinition metadata, ProtocolEntityFactory protocolEntityFactory) throws IOException; + + /** + * Sets an InputStream instance that will be used to send data + * to the MySQL server for a "LOAD DATA LOCAL INFILE" statement + * rather than a FileInputStream or URLInputStream that represents + * the path given as an argument to the statement. + * + * This stream will be read to completion upon execution of a + * "LOAD DATA LOCAL INFILE" statement, and will automatically + * be closed by the driver, so it needs to be reset + * before each call to execute*() that would cause the MySQL + * server to request data to fulfill the request for + * "LOAD DATA LOCAL INFILE". + * + * If this value is set to NULL, the driver will revert to using + * a FileInputStream or URLInputStream as required. + * + * @param stream + * input stream + */ + void setLocalInfileInputStream(InputStream stream); + + /** + * Returns the InputStream instance that will be used to send + * data in response to a "LOAD DATA LOCAL INFILE" statement. + * + * This method returns NULL if no such stream has been set + * via setLocalInfileInputStream(). + * + * @return input stream + */ + InputStream getLocalInfileInputStream(); + + /** + * Returns the comment that will be prepended to all statements + * sent to the server. + * + * @return query comment string + */ + String getQueryComment(); + + /** + * Sets the comment that will be prepended to all statements + * sent to the server. Do not use slash-star or star-slash tokens + * in the comment as these will be added by the driver itself. + * + * @param comment + * query comment string + */ + void setQueryComment(String comment); + + /** + * Read messages from server and deliver them to resultBuilder. + * + * @param resultBuilder + * {@link ResultBuilder} instance + * @param + * result type + * @return {@link QueryResult} + */ + T readQueryResult(ResultBuilder resultBuilder); + + void close() throws IOException; + + void configureTimeZone(); + + void initServerSession(); + + /** + * Return Protocol to its initial state right after successful connect. + */ + void reset(); + + String getQueryTimingUnits(); + + public static interface ProtocolEventListener { + + public enum EventType { + SERVER_SHUTDOWN, SERVER_CLOSED_SESSION; + } + + void handleEvent(EventType type, Object info, Throwable reason); + } + + public static interface ProtocolEventHandler { + /** + * Add listener for this protocol events. + * + * @param l + * {@link ProtocolEventListener} instance. + */ + void addListener(ProtocolEventListener l); + + /** + * Remove protocol listener. + * + * @param l + * {@link ProtocolEventListener} instance. + */ + void removeListener(ProtocolEventListener l); + + void invokeListeners(EventType type, Throwable reason); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ProtocolEntity.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ProtocolEntity.java new file mode 100644 index 0000000..2f6c155 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ProtocolEntity.java @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2016, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +public interface ProtocolEntity { + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ProtocolEntityFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ProtocolEntityFactory.java new file mode 100644 index 0000000..b0bafb8 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ProtocolEntityFactory.java @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2016, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import com.mysql.cj.exceptions.CJOperationNotSupportedException; +import com.mysql.cj.exceptions.ExceptionFactory; + +public interface ProtocolEntityFactory { + + /** + * Create ProtocolEntity of type {@link T} from protocol message. + * + * @param message + * {@link Message} instance + * @return T + */ + default T createFromMessage(M message) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not allowed"); + } + + default Resultset.Type getResultSetType() { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not allowed"); + } + + default Resultset.Concurrency getResultSetConcurrency() { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not allowed"); + } + + default int getFetchSize() { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not allowed"); + } + + /** + * Create object from protocol entity. + * + * @param protocolEntity + * the {@link ProtocolEntity} to create from + * @return a new ProtocolEntity + */ + default T createFromProtocolEntity(ProtocolEntity protocolEntity) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not allowed"); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ProtocolEntityReader.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ProtocolEntityReader.java new file mode 100644 index 0000000..593319d --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ProtocolEntityReader.java @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2016, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.io.IOException; + +import com.mysql.cj.exceptions.CJOperationNotSupportedException; +import com.mysql.cj.exceptions.ExceptionFactory; + +public interface ProtocolEntityReader { + + /** + * + * @param sf + * {@link ProtocolEntityFactory} instance + * @return {@link ProtocolEntity} instance + * @throws IOException + * if an error occurs + */ + default T read(ProtocolEntityFactory sf) throws IOException { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not allowed"); + } + + /** + * Reads one result set off of the wire, if the result is actually an + * update count, creates an update-count only result set. + * + * @param maxRows + * the maximum number of rows to read (-1 means all rows) + * @param streamResults + * should the driver leave the results on the wire, + * and read them only when needed? + * @param resultPacket + * the first packet of information in the result set + * @param metadata + * use this metadata instead of the one provided on wire + * @param protocolEntityFactory + * {@link ProtocolEntityFactory} instance + * + * @return a result set that either represents the rows, or an update count + * + * @throws IOException + * if an error occurs while reading the rows + */ + default T read(int maxRows, boolean streamResults, M resultPacket, ColumnDefinition metadata, ProtocolEntityFactory protocolEntityFactory) + throws IOException { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not allowed"); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ResultBuilder.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ResultBuilder.java new file mode 100644 index 0000000..ce6c900 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ResultBuilder.java @@ -0,0 +1,57 @@ +/* + * Copyright (c) 2019, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +/** + * Classes implementing this interface are responsible for building result of specific type from incoming ProtocolEntity objects. + * + * @param + * result type + */ +public interface ResultBuilder { + + /** + * Add ProtocolEntity. + * + * @param entity + * {@link ProtocolEntity} object + * @return true - if this builder is ready for building the result; + * false - if another ProtocolEntity is required + */ + boolean addProtocolEntity(ProtocolEntity entity); + + /** + * Build the result using already added protocol instances. + * + * @return {@link T} instance + */ + T build(); + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ResultStreamer.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ResultStreamer.java new file mode 100644 index 0000000..5c196b4 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ResultStreamer.java @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +/** + * A result streamer is a result object that is streaming results from the current connection. It allows to stream as long as nothing else needs to happen on + * the connection. Once something else needs to happen the streamed is notified to "complete streaming" at which point he can throw an exception, discard rows, + * buffer rows, etc. The connection is then free to execute the next command. + */ +public interface ResultStreamer { + /** + * Finish the result streaming. This happens if a new command is started or the warnings/etc are requested. This is safe to call multiple times and only has + * an effect the first time. + */ + void finishStreaming(); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/Resultset.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/Resultset.java new file mode 100644 index 0000000..4725e25 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/Resultset.java @@ -0,0 +1,198 @@ +/* + * Copyright (c) 2016, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +/** + * Represents protocol specific result set, + * eg., for native protocol, a ProtocolText::Resultset or ProtocolBinary::Resultset entity. + * + * See: + * http://dev.mysql.com/doc/internals/en/com-query-response.html#packet-ProtocolText::Resultset + * http://dev.mysql.com/doc/internals/en/binary-protocol-resultset.html + * + */ +public interface Resultset extends ProtocolEntity { + + public enum Concurrency { + /** + * The constant indicating the concurrency mode for a + * Resultset object that may NOT be updated. + */ + READ_ONLY(java.sql.ResultSet.CONCUR_READ_ONLY), + + /** + * The constant indicating the concurrency mode for a + * Resultset object that may be updated. + */ + UPDATABLE(java.sql.ResultSet.CONCUR_UPDATABLE); + + private int value; + + private Concurrency(int jdbcRsConcur) { + this.value = jdbcRsConcur; + } + + public int getIntValue() { + return this.value; + } + + public static Concurrency fromValue(int concurMode, Concurrency backupValue) { + for (Concurrency c : values()) { + if (c.getIntValue() == concurMode) { + return c; + } + } + return backupValue; + } + + } + + public enum Type { + /** + * The constant indicating the type for a Resultset object + * whose cursor may move only forward. + */ + FORWARD_ONLY(java.sql.ResultSet.TYPE_FORWARD_ONLY), + + /** + * The constant indicating the type for a Resultset object + * that is scrollable but generally not sensitive to changes to the data + * that underlies the Resultset. + */ + SCROLL_INSENSITIVE(java.sql.ResultSet.TYPE_SCROLL_INSENSITIVE), + + /** + * The constant indicating the type for a Resultset object + * that is scrollable and generally sensitive to changes to the data + * that underlies the Resultset. + */ + SCROLL_SENSITIVE(java.sql.ResultSet.TYPE_SCROLL_SENSITIVE); + + private int value; + + private Type(int jdbcRsType) { + this.value = jdbcRsType; + } + + public int getIntValue() { + return this.value; + } + + public static Type fromValue(int rsType, Type backupValue) { + for (Type t : values()) { + if (t.getIntValue() == rsType) { + return t; + } + } + return backupValue; + } + } + + /** + * Sometimes the driver doesn't have metadata before consuming the result set rows (because it's cached), + * or need to coerce the metadata returned by queries into that required by the particular specification + * (eg metadata returned by metadata queries into that required by the JDBC specification). + * So it can call this to set it after the fact. + * + * @param metadata + * field-level metadata for the result set + */ + void setColumnDefinition(ColumnDefinition metadata); + + ColumnDefinition getColumnDefinition(); + + /** + * Does the result set contain rows, or is it the result of a DDL or DML statement? + * + * @return true if result set contains rows + */ + boolean hasRows(); + + ResultsetRows getRows(); + + /** + * Set metadata of this Resultset to ResultsetRows it contains. + */ + void initRowsWithMetadata(); + + /** + * The id (used when profiling) to identify us + * + * @return result id + */ + int getResultId(); + + /** + * @param nextResultset + * Sets the next result set in the result set chain for multiple result sets. + */ + void setNextResultset(Resultset nextResultset); + + /** + * Returns the next ResultSet in a multi-resultset "chain", if any, + * null if none exists. + * + * @return the next Resultset + */ + Resultset getNextResultset(); + + /** + * Clears the reference to the next result set in a multi-result set + * "chain". + */ + void clearNextResultset(); + + /** + * Returns the update count for this result set (if one exists), otherwise + * -1. + * + * @return return the update count for this result set (if one exists), otherwise + * -1. + */ + long getUpdateCount(); + + /** + * Returns the AUTO_INCREMENT value for the DDL/DML statement which created + * this result set. + * + * @return the AUTO_INCREMENT value for the DDL/DML statement which created + * this result set. + */ + long getUpdateID(); + + /** + * Returns the server informational message returned from a DDL or DML + * statement (if any), or null if none. + * + * @return the server informational message + */ + String getServerInfo(); + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ResultsetRow.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ResultsetRow.java new file mode 100644 index 0000000..51df317 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ResultsetRow.java @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2016, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import com.mysql.cj.result.Row; + +/** + * Classes that implement this interface represent one row of data from the MySQL server that might be stored in different ways depending on whether the result + * set was streaming (so they wrap a reusable packet), or whether the result set was cached or via a server-side cursor (so they represent a byte[][]). + * + * Notice that no bounds checking is expected for implementors of this interface, it happens in ResultSetImpl. + */ +public interface ResultsetRow extends Row, ProtocolEntity { + + default boolean isBinaryEncoded() { + return false; + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ResultsetRows.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ResultsetRows.java new file mode 100644 index 0000000..2050593 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ResultsetRows.java @@ -0,0 +1,191 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import com.mysql.cj.Messages; +import com.mysql.cj.exceptions.CJOperationNotSupportedException; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.result.Row; +import com.mysql.cj.result.RowList; + +/** + * This interface abstracts away how row data is accessed by the result set. It is meant to allow a static implementation (Current version), and a streaming + * one. It extends the {@link RowList} functionality by providing row positioning, updatability and ownership. + */ +public interface ResultsetRows extends RowList, ProtocolEntity { + + /** + * Adds a row. + * + * @param row + * the row to add + */ + default void addRow(Row row) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, Messages.getString("OperationNotSupportedException.0")); + } + + /** + * Moves to after last. + * + */ + default void afterLast() { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, Messages.getString("OperationNotSupportedException.0")); + } + + /** + * Moves to before first. + * + */ + default void beforeFirst() { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, Messages.getString("OperationNotSupportedException.0")); + } + + /** + * Moves to before last. + * + */ + default void beforeLast() { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, Messages.getString("OperationNotSupportedException.0")); + } + + /** + * We're done. + * + */ + default void close() { + } + + /** + * Returns the result set that 'owns' this RowData + * + * @return {@link ResultsetRowsOwner} + */ + ResultsetRowsOwner getOwner(); + + /** + * Returns true if we got the last element. + * + * @return true if after last row + */ + boolean isAfterLast(); + + /** + * Returns if iteration has not occured yet. + * + * @return true if before first row + */ + boolean isBeforeFirst(); + + /** + * Returns true if the result set is dynamic. + * + * This means that move back and move forward won't work because we do not + * hold on to the records. + * + * @return true if this result set is streaming from the server + */ + default boolean isDynamic() { + return true; + } + + /** + * Has no records. + * + * @return true if no records + */ + default boolean isEmpty() { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, Messages.getString("OperationNotSupportedException.0")); + } + + /** + * Are we on the first row of the result set? + * + * @return true if on first row + */ + default boolean isFirst() { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, Messages.getString("OperationNotSupportedException.0")); + } + + /** + * Are we on the last row of the result set? + * + * @return true if on last row + */ + default boolean isLast() { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, Messages.getString("OperationNotSupportedException.0")); + } + + /** + * Moves the current position relative 'rows' from the current position. + * + * @param rows + * the relative number of rows to move + */ + default void moveRowRelative(int rows) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, Messages.getString("OperationNotSupportedException.0")); + } + + /** + * Moves the current position in the result set to the given row number. + * + * @param rowNumber + * row to move to + */ + default void setCurrentRow(int rowNumber) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, Messages.getString("OperationNotSupportedException.0")); + } + + /** + * Set the result set that 'owns' this RowData + * + * @param rs + * the result set that 'owns' this RowData + */ + void setOwner(ResultsetRowsOwner rs); + + /** + * Did this result set have no rows? + * + * @return true if the result set did not have rows + */ + boolean wasEmpty(); + + /** + * Sometimes the driver doesn't have metadata until after + * the statement has the result set in-hand (because it's cached), + * so it can call this to set it after the fact. + * + * @param columnDefinition + * field-level metadata for the result set + */ + void setMetadata(ColumnDefinition columnDefinition); + + ColumnDefinition getMetadata(); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ResultsetRowsOwner.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ResultsetRowsOwner.java new file mode 100644 index 0000000..3cd4628 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ResultsetRowsOwner.java @@ -0,0 +1,63 @@ +/* + * Copyright (c) 2016, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import com.mysql.cj.MysqlConnection; +import com.mysql.cj.Query; +import com.mysql.cj.Session; + +public interface ResultsetRowsOwner { + + void closeOwner(boolean calledExplicitly); + + MysqlConnection getConnection(); + + Session getSession(); + + Object getSyncMutex(); + + /** + * StackTrace generated where ResultSet was created... used when profiling + * + * @return string representation of a stack trace + */ + String getPointOfOrigin(); + + int getOwnerFetchSize(); + + Query getOwningQuery(); + + int getOwningStatementMaxRows(); + + int getOwningStatementFetchSize(); + + long getOwningStatementServerId(); + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ServerCapabilities.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ServerCapabilities.java new file mode 100644 index 0000000..756ec55 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ServerCapabilities.java @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2015, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import com.mysql.cj.ServerVersion; + +/** + * Represents server capabilities, retrieved right after creating physical connection and before handshake. + */ +public interface ServerCapabilities { + + int getCapabilityFlags(); + + void setCapabilityFlags(int capabilityFlags); + + ServerVersion getServerVersion(); + + long getThreadId(); + + void setThreadId(long threadId); + + boolean serverSupportsFracSecs(); + + int getServerDefaultCollationIndex(); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ServerSession.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ServerSession.java new file mode 100644 index 0000000..1fdea18 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ServerSession.java @@ -0,0 +1,200 @@ +/* + * Copyright (c) 2015, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.util.Map; +import java.util.TimeZone; + +import com.mysql.cj.CharsetSettings; +import com.mysql.cj.ServerVersion; +import com.mysql.cj.exceptions.CJOperationNotSupportedException; +import com.mysql.cj.exceptions.ExceptionFactory; + +/** + * Keeps the effective states of server/session variables, + * contains methods for initial retrieving of these states and for their actualization. + */ +public interface ServerSession { + + /** + * There was no change between old and current SERVER_STATUS_IN_TRANS state and it is 0. + */ + public static int TRANSACTION_NOT_STARTED = 0; + + /** + * There was no change between old and current SERVER_STATUS_IN_TRANS state and it is 1. + */ + public static int TRANSACTION_IN_PROGRESS = 1; + + /** + * Old SERVER_STATUS_IN_TRANS state was 0 and current one is 1. + */ + public static int TRANSACTION_STARTED = 2; + + /** + * Old SERVER_STATUS_IN_TRANS state was 1 and current one is 0. + */ + public static int TRANSACTION_COMPLETED = 3; + + ServerCapabilities getCapabilities(); + + void setCapabilities(ServerCapabilities capabilities); + + int getStatusFlags(); + + /** + * Sets new server status (from response) without saving it's old state + * + * @param statusFlags + * server status flags + */ + void setStatusFlags(int statusFlags); + + /** + * Sets new server status (from response) + * + * @param statusFlags + * new server status flags + * @param saveOldStatusFlags + * true if old server status flags should be preserved + */ + void setStatusFlags(int statusFlags, boolean saveOldStatusFlags); + + int getOldStatusFlags(); + + void setOldStatusFlags(int statusFlags); + + /** + * + * @return TRANSACTION_NOT_STARTED, TRANSACTION_IN_PROGRESS, TRANSACTION_STARTED or TRANSACTION_COMPLETED + */ + int getTransactionState(); + + boolean inTransactionOnServer(); + + /** + * Server will only open a cursor and set this flag if it can, otherwise it punts and goes back to mysql_store_results() behavior. + * + * @return SERVER_STATUS_CURSOR_EXISTS status flag value. + */ + boolean cursorExists(); + + boolean isAutocommit(); + + boolean hasMoreResults(); + + boolean isLastRowSent(); + + boolean noGoodIndexUsed(); + + boolean noIndexUsed(); + + boolean queryWasSlow(); + + long getClientParam(); + + void setClientParam(long clientParam); + + boolean hasLongColumnInfo(); + + boolean useMultiResults(); + + boolean isEOFDeprecated(); + + boolean supportsQueryAttributes(); + + Map getServerVariables(); + + String getServerVariable(String name); + + int getServerVariable(String variableName, int fallbackValue); + + void setServerVariables(Map serverVariables); + + /** + * Get the version of the MySQL server we are talking to. + * + * @return {@link ServerVersion} + */ + ServerVersion getServerVersion(); + + /** + * Is the version of the MySQL server we are connected to the given + * version? + * + * @param version + * the version to check for + * + * @return true if the version of the MySQL server we are connected is the + * given version + */ + boolean isVersion(ServerVersion version); + + /** + * Is the server configured to use lower-case table names only? + * + * @return true if lower_case_table_names is 'on' + */ + boolean isLowerCaseTableNames(); + + boolean storesLowerCaseTableNames(); + + boolean isQueryCacheEnabled(); + + boolean isNoBackslashEscapesSet(); + + boolean useAnsiQuotedIdentifiers(); + + public boolean isServerTruncatesFracSecs(); + + boolean isAutoCommit(); + + void setAutoCommit(boolean autoCommit); + + TimeZone getSessionTimeZone(); + + void setSessionTimeZone(TimeZone sessionTimeZone); + + /** + * The default time zone used to marshal date/time values to/from the server. This is used when methods like getDate() are called without a calendar + * argument. + * + * @return The default JVM time zone + */ + TimeZone getDefaultTimeZone(); + + default ServerSessionStateController getServerSessionStateController() { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not supported"); + } + + CharsetSettings getCharsetSettings(); + + void setCharsetSettings(CharsetSettings charsetSettings); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ServerSessionStateController.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ServerSessionStateController.java new file mode 100644 index 0000000..ef49378 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ServerSessionStateController.java @@ -0,0 +1,147 @@ +/* + * Copyright (c) 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.util.ArrayList; +import java.util.List; + +import com.mysql.cj.exceptions.CJOperationNotSupportedException; +import com.mysql.cj.exceptions.ExceptionFactory; + +public interface ServerSessionStateController { + + public static int SESSION_TRACK_SYSTEM_VARIABLES = 0x00; + public static int SESSION_TRACK_SCHEMA = 0x01; + public static int SESSION_TRACK_STATE_CHANGE = 0x02; + public static int SESSION_TRACK_GTIDS = 0x03; + public static int SESSION_TRACK_TRANSACTION_CHARACTERISTICS = 0x04; + public static int SESSION_TRACK_TRANSACTION_STATE = 0x05; + + /** + * Set the object containing server session changes collected from the latest query execution. Used internally. + * + * @param changes + * {@link ServerSessionStateChanges} object. + * + */ + default void setSessionStateChanges(ServerSessionStateChanges changes) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not supported"); + } + + /** + * Get the object containing server session changes collected from the latest query execution. + *

+ * Please note that the driver could issue some queries internally. With that there is no guarantee that all session changes are reflected in the + * {@link ServerSessionStateChanges} object after the recent user's query. If this is an issue, a {@link SessionStateChangesListener} can be added via + * {@link #addSessionStateChangesListener(SessionStateChangesListener)} to catch all session changes. + *

+ * + * @return {@link ServerSessionStateChanges} object. + */ + default ServerSessionStateChanges getSessionStateChanges() { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not supported"); + } + + @FunctionalInterface + public static interface SessionStateChangesListener { + void handleSessionStateChanges(ServerSessionStateChanges changes); + } + + /** + * Add the {@link SessionStateChangesListener} that will process {@link ServerSessionStateChanges} on it's arrival. + * + * @param l + * {@link SessionStateChangesListener} object. + */ + default void addSessionStateChangesListener(SessionStateChangesListener l) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not supported"); + } + + /** + * Remove {@link SessionStateChangesListener}. + * + * @param l + * {@link SessionStateChangesListener} object. + */ + default void removeSessionStateChangesListener(SessionStateChangesListener l) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not supported"); + } + + /** + * The object containing server session changes collected from the latest query execution. + *

+ * Driver is getting these changes when connection property trackSessionState=true and server supports session tracking. + *

+ * + */ + public static interface ServerSessionStateChanges { + List getSessionStateChangesList(); + } + + /** + * A single server session change record. + *

+ * The server messages about session changes are parsed according to their known types: + *

    + *
  • {@link #SESSION_TRACK_SYSTEM_VARIABLES} - two values, the system variable name and it's new value;
    • + *
  • {@link #SESSION_TRACK_SCHEMA} - single value, the new schema name;
    • + *
  • {@link #SESSION_TRACK_STATE_CHANGE} - single value, "1" or "0";
    • + *
  • {@link #SESSION_TRACK_GTIDS} - single value, list of GTIDs as reported by server;
    • + *
  • {@link #SESSION_TRACK_TRANSACTION_CHARACTERISTICS} - single value, transaction characteristics statement;
    • + *
  • {@link #SESSION_TRACK_TRANSACTION_STATE} - single value, transaction state record.
    • + *
+ * For the unknown change type the raw payload is written into the single value. + *

+ *

+ * See more details in the server documentation. + *

+ */ + public static class SessionStateChange { + private int type; + private List values = new ArrayList<>(); + + public SessionStateChange(int type) { + this.type = type; + } + + public int getType() { + return this.type; + } + + public List getValues() { + return this.values; + } + + public SessionStateChange addValue(String value) { + this.values.add(value); + return this; + } + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/SocketConnection.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/SocketConnection.java new file mode 100644 index 0000000..9bc86ec --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/SocketConnection.java @@ -0,0 +1,113 @@ +/* + * Copyright (c) 2015, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.io.BufferedOutputStream; +import java.io.IOException; +import java.net.Socket; + +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.ExceptionInterceptor; +import com.mysql.cj.exceptions.FeatureNotAvailableException; +import com.mysql.cj.exceptions.SSLParamsException; +import com.mysql.cj.log.Log; + +/** + * Represents physical connection with endpoint + */ +public interface SocketConnection { + + /** + * Connect to the MySQL server and setup a stream connection. + * + * @param host + * the hostname to connect to + * @param port + * the port number that the server is listening on + * @param propertySet + * the PropertySet with required connection options + * @param exceptionInterceptor + * exception interceptor + * @param log + * logger + * @param loginTimeout + * the driver login time limit in milliseconds + */ + void connect(String host, int port, PropertySet propertySet, ExceptionInterceptor exceptionInterceptor, Log log, int loginTimeout); + + void performTlsHandshake(ServerSession serverSession) throws SSLParamsException, FeatureNotAvailableException, IOException; + + /** + * Start a TLS handshake + * + * @param serverSession + * server session state object + * @param log + * logger + * @throws SSLParamsException + * @throws FeatureNotAvailableException + * @throws IOException + */ + default void performTlsHandshake(ServerSession serverSession, Log log) throws SSLParamsException, FeatureNotAvailableException, IOException { + performTlsHandshake(serverSession); + } + + void forceClose(); + + NetworkResources getNetworkResources(); + + /** + * Returns the host this IO is connected to + * + * @return host name + */ + String getHost(); + + int getPort(); + + Socket getMysqlSocket() throws IOException; + + FullReadInputStream getMysqlInput() throws IOException; + + void setMysqlInput(FullReadInputStream mysqlInput); + + BufferedOutputStream getMysqlOutput() throws IOException; + + boolean isSSLEstablished(); + + SocketFactory getSocketFactory(); + + void setSocketFactory(SocketFactory socketFactory); + + ExceptionInterceptor getExceptionInterceptor(); + + PropertySet getPropertySet(); + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/SocketFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/SocketFactory.java new file mode 100644 index 0000000..2bf4348 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/SocketFactory.java @@ -0,0 +1,127 @@ +/* + * Copyright (c) 2002, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.io.Closeable; +import java.io.IOException; + +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.log.Log; + +/** + * Interface to allow pluggable socket creation in the driver + */ +public interface SocketFactory extends SocketMetadata { + + /** + * Creates a new socket or channel using the given properties. Properties are parsed by + * the driver from the URL. All properties other than sensitive ones (user + * and password) are passed to this method. The driver will instantiate the + * socket factory with the class name given in the property + * "socketFactory", where the standard is com.mysql.cj.protocol.StandardSocketFactory Implementing classes + * are responsible for handling synchronization of this method (if needed). + * + * @param host + * the hostname passed in the URL. It will be a single + * hostname, as the driver parses multi-hosts (for failover) and + * calls this method for each host connection attempt. + * + * @param portNumber + * the port number to connect to (if required). + * + * @param props + * properties passed to the driver via the URL and/or properties + * instance. + * @param loginTimeout + * login timeout in milliseconds + * @param + * result type + * + * @return a socket connected to the given host + * @throws IOException + * if an I/O error occurs + */ + T connect(String host, int portNumber, PropertySet props, int loginTimeout) throws IOException; + + /** + * Called by the driver before issuing the MySQL protocol handshake. + * + * @throws IOException + * if an I/O error occurs + */ + default void beforeHandshake() throws IOException { + } + + /** + * If required, called by the driver during MySQL protocol handshake to transform + * original socket to SSL socket and perform TLS handshake. + * + * @param socketConnection + * current SocketConnection + * @param serverSession + * current ServerSession + * @param + * result type + * @return SSL socket + * @throws IOException + * if an I/O error occurs + */ + T performTlsHandshake(SocketConnection socketConnection, ServerSession serverSession) throws IOException; + + /** + * If required, called by the driver during MySQL protocol handshake to transform + * original socket to SSL socket and perform TLS handshake. + * + * @param socketConnection + * current SocketConnection + * @param serverSession + * current ServerSession + * @param + * result type + * @param log + * logger + * @return SSL socket + * @throws IOException + * if an I/O error occurs + */ + default T performTlsHandshake(SocketConnection socketConnection, ServerSession serverSession, Log log) throws IOException { + return performTlsHandshake(socketConnection, serverSession); + } + + /** + * Called by the driver after completing the MySQL protocol handshake and + * reading the results of the authentication. + * + * @throws IOException + * if an I/O error occurs + */ + default void afterHandshake() throws IOException { + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/SocketMetadata.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/SocketMetadata.java new file mode 100644 index 0000000..801a777 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/SocketMetadata.java @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2011, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.net.InetAddress; +import java.net.InetSocketAddress; +import java.net.SocketAddress; +import java.net.UnknownHostException; + +import com.mysql.cj.Messages; +import com.mysql.cj.Session; + +public interface SocketMetadata { + + default boolean isLocallyConnected(Session sess) { + String processHost = sess.getProcessHost(); + return isLocallyConnected(sess, processHost); + } + + default boolean isLocallyConnected(Session sess, String processHost) { + if (processHost != null) { + sess.getLog().logDebug(Messages.getString("SocketMetadata.0", new Object[] { processHost })); + + int endIndex = processHost.lastIndexOf(":"); + if (endIndex != -1) { + processHost = processHost.substring(0, endIndex); + } + + try { + + InetAddress[] whereMysqlThinksIConnectedFrom = InetAddress.getAllByName(processHost); + + SocketAddress remoteSocketAddr = sess.getRemoteSocketAddress(); + + if (remoteSocketAddr instanceof InetSocketAddress) { + InetAddress whereIConnectedTo = ((InetSocketAddress) remoteSocketAddr).getAddress(); + + for (InetAddress hostAddr : whereMysqlThinksIConnectedFrom) { + if (hostAddr.equals(whereIConnectedTo)) { + sess.getLog().logDebug(Messages.getString("SocketMetadata.1", new Object[] { hostAddr, whereIConnectedTo })); + return true; + } + sess.getLog().logDebug(Messages.getString("SocketMetadata.2", new Object[] { hostAddr, whereIConnectedTo })); + } + + } else { + sess.getLog().logDebug(Messages.getString("SocketMetadata.3", new Object[] { remoteSocketAddr })); + } + + return false; + } catch (UnknownHostException e) { + sess.getLog().logWarn(Messages.getString("Connection.CantDetectLocalConnect", new Object[] { processHost }), e); + + return false; + } + + } + + return false; + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ValueDecoder.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ValueDecoder.java new file mode 100644 index 0000000..6f77704 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/ValueDecoder.java @@ -0,0 +1,79 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import com.mysql.cj.result.Field; +import com.mysql.cj.result.ValueFactory; + +/** + * A value decoder is responsible for interpreting a byte array as a value. The type of the value is encoded in the method call. After decoding, the value + * decoder passes an intermediate representation of the value to a {@link ValueFactory} for result value creation. + * + * @since 6.0 + */ +public interface ValueDecoder { + T decodeDate(byte[] bytes, int offset, int length, ValueFactory vf); + + T decodeTime(byte[] bytes, int offset, int length, int scale, ValueFactory vf); + + T decodeTimestamp(byte[] bytes, int offset, int length, int scale, ValueFactory vf); + + T decodeDatetime(byte[] bytes, int offset, int length, int scale, ValueFactory vf); + + T decodeInt1(byte[] bytes, int offset, int length, ValueFactory vf); + + T decodeUInt1(byte[] bytes, int offset, int length, ValueFactory vf); + + T decodeInt2(byte[] bytes, int offset, int length, ValueFactory vf); + + T decodeUInt2(byte[] bytes, int offset, int length, ValueFactory vf); + + T decodeInt4(byte[] bytes, int offset, int length, ValueFactory vf); + + T decodeUInt4(byte[] bytes, int offset, int length, ValueFactory vf); + + T decodeInt8(byte[] bytes, int offset, int length, ValueFactory vf); + + T decodeUInt8(byte[] bytes, int offset, int length, ValueFactory vf); + + T decodeFloat(byte[] bytes, int offset, int length, ValueFactory vf); + + T decodeDouble(byte[] bytes, int offset, int length, ValueFactory vf); + + T decodeDecimal(byte[] bytes, int offset, int length, ValueFactory vf); + + T decodeByteArray(byte[] bytes, int offset, int length, Field f, ValueFactory vf); + + T decodeBit(byte[] bytes, int offset, int length, ValueFactory vf); + + T decodeSet(byte[] bytes, int offset, int length, Field f, ValueFactory vf); + + T decodeYear(byte[] bytes, int offset, int length, ValueFactory vf); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/Warning.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/Warning.java new file mode 100644 index 0000000..f598a82 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/Warning.java @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2016, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +public interface Warning { + /** + * Get warning level. + * + * @return Warning level + */ + int getLevel(); + + /** + * Get warning code. + * + * @return Warning code + */ + long getCode(); + + /** + * Get warning message. + * + * @return Warning message + */ + String getMessage(); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/WatchableStream.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/WatchableStream.java new file mode 100644 index 0000000..b9092e0 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/protocol/WatchableStream.java @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +public interface WatchableStream { + + void setWatcher(OutputStreamWatcher watcher); + + int size(); + + byte toByteArray()[]; + + void write(byte b[], int off, int len); + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/result/Field.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/result/Field.java new file mode 100644 index 0000000..ebfc9f7 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/result/Field.java @@ -0,0 +1,422 @@ +/* + * Copyright (c) 2002, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import com.mysql.cj.MysqlType; +import com.mysql.cj.protocol.ProtocolEntity; +import com.mysql.cj.util.LazyString; + +/** + * Field is a class used to describe fields in a ResultSet + */ +public class Field implements ProtocolEntity { + + private int collationIndex = 0; + + private String encoding = "US-ASCII"; + + private int colDecimals; + + private short colFlag; + + private LazyString databaseName = null; + private LazyString tableName = null; + private LazyString originalTableName = null; + private LazyString columnName = null; + private LazyString originalColumnName = null; + + private String fullName = null; + + private long length; // Internal length of the field; + + private int mysqlTypeId = -1; // the MySQL type ID in legacy protocol + + private MysqlType mysqlType = MysqlType.UNKNOWN; + + public Field(LazyString databaseName, LazyString tableName, LazyString originalTableName, LazyString columnName, LazyString originalColumnName, long length, + int mysqlTypeId, short colFlag, int colDecimals, int collationIndex, String encoding, MysqlType mysqlType) { + this.databaseName = databaseName; + this.tableName = tableName; + this.originalTableName = originalTableName; + this.columnName = columnName; + this.originalColumnName = originalColumnName; + this.length = length; + this.colFlag = colFlag; + this.colDecimals = colDecimals; + this.mysqlTypeId = mysqlTypeId; + this.collationIndex = collationIndex; + + // ucs2, utf16, and utf32 cannot be used as a client character set, but if it was received from server under some circumstances we can parse them as utf16 + this.encoding = "UnicodeBig".equals(encoding) ? "UTF-16" : encoding; + + // MySQL encodes JSON data with utf8mb4. + if (mysqlType == MysqlType.JSON) { + this.encoding = "UTF-8"; + } + + this.mysqlType = mysqlType; + + adjustFlagsByMysqlType(); + } + + private void adjustFlagsByMysqlType() { + + switch (this.mysqlType) { + case BIT: + if (this.length > 1) { + this.colFlag |= MysqlType.FIELD_FLAG_BINARY; + this.colFlag |= MysqlType.FIELD_FLAG_BLOB; + } + break; + + case BINARY: + case VARBINARY: + this.colFlag |= MysqlType.FIELD_FLAG_BINARY; + this.colFlag |= MysqlType.FIELD_FLAG_BLOB; + break; + + case DECIMAL_UNSIGNED: + case TINYINT_UNSIGNED: + case SMALLINT_UNSIGNED: + case INT_UNSIGNED: + case FLOAT_UNSIGNED: + case DOUBLE_UNSIGNED: + case BIGINT_UNSIGNED: + case MEDIUMINT_UNSIGNED: + this.colFlag |= MysqlType.FIELD_FLAG_UNSIGNED; + break; + + default: + break; + } + + } + + /** + * Used by prepared statements to re-use result set data conversion methods + * when generating bound parameter retrieval instance for statement interceptors. + * + * @param tableName + * not used + * @param columnName + * not used + * @param collationIndex + * the MySQL collation/character set index + * @param encoding + * encoding of data in this field + * @param mysqlType + * {@link MysqlType} + * @param length + * length in characters or bytes (for BINARY data). + */ + public Field(String tableName, String columnName, int collationIndex, String encoding, MysqlType mysqlType, int length) { + + this.databaseName = new LazyString(null); + this.tableName = new LazyString(tableName); + this.originalTableName = new LazyString(null); + this.columnName = new LazyString(columnName); + this.originalColumnName = new LazyString(null); + this.length = length; + this.mysqlType = mysqlType; + this.colFlag = 0; + this.colDecimals = 0; + + adjustFlagsByMysqlType(); + + switch (mysqlType) { + case CHAR: + case VARCHAR: + case TINYTEXT: + case TEXT: + case MEDIUMTEXT: + case LONGTEXT: + case JSON: + // TODO: this becomes moot when DBMD results aren't built from ByteArrayRow + // it possibly overrides correct encoding already existing in the Field instance + this.collationIndex = collationIndex; + + // ucs2, utf16, and utf32 cannot be used as a client character set, but if it was received from server under some circumstances we can parse them as utf16 + this.encoding = "UnicodeBig".equals(encoding) ? "UTF-16" : encoding; + + break; + default: + // ignoring charsets for non-string types + } + } + + /** + * Returns the Java encoding for this field. + * + * @return the Java encoding + */ + public String getEncoding() { + return this.encoding; + } + + public String getColumnLabel() { + return getName(); + } + + public String getDatabaseName() { + return this.databaseName.toString(); + } + + public int getDecimals() { + return this.colDecimals; + } + + public String getFullName() { + if (this.fullName == null) { + StringBuilder fullNameBuf = new StringBuilder(this.tableName.length() + 1 + this.columnName.length()); + fullNameBuf.append(this.tableName.toString()); + fullNameBuf.append('.'); + fullNameBuf.append(this.columnName.toString()); + this.fullName = fullNameBuf.toString(); + } + + return this.fullName; + } + + public long getLength() { + return this.length; + } + + public int getMysqlTypeId() { + return this.mysqlTypeId; + } + + public void setMysqlTypeId(int id) { + this.mysqlTypeId = id; + } + + public String getName() { + return this.columnName.toString(); + } + + public String getOriginalName() { + return this.originalColumnName.toString(); + } + + public String getOriginalTableName() { + return this.originalTableName.toString(); + } + + public int getJavaType() { + return this.mysqlType.getJdbcType(); + } + + public String getTableName() { + return this.tableName.toString(); + } + + public boolean isAutoIncrement() { + return ((this.colFlag & MysqlType.FIELD_FLAG_AUTO_INCREMENT) > 0); + } + + public boolean isBinary() { + return ((this.colFlag & MysqlType.FIELD_FLAG_BINARY) > 0); + } + + public void setBinary() { + this.colFlag |= MysqlType.FIELD_FLAG_BINARY; + } + + public boolean isBlob() { + return ((this.colFlag & MysqlType.FIELD_FLAG_BLOB) > 0); + } + + public void setBlob() { + this.colFlag |= MysqlType.FIELD_FLAG_BLOB; + } + + public boolean isMultipleKey() { + return ((this.colFlag & MysqlType.FIELD_FLAG_MULTIPLE_KEY) > 0); + } + + public boolean isNotNull() { + return ((this.colFlag & MysqlType.FIELD_FLAG_NOT_NULL) > 0); + } + + public boolean isPrimaryKey() { + return ((this.colFlag & MysqlType.FIELD_FLAG_PRIMARY_KEY) > 0); + } + + public boolean isFromFunction() { + return this.originalTableName.length() == 0; + } + + /** + * Is this field _definitely_ not writable? + * + * @return true if this field can not be written to in an INSERT/UPDATE + * statement. + */ + public boolean isReadOnly() { + return this.originalColumnName.length() == 0 && this.originalTableName.length() == 0; + } + + public boolean isUniqueKey() { + return ((this.colFlag & MysqlType.FIELD_FLAG_UNIQUE_KEY) > 0); + } + + public boolean isUnsigned() { + return ((this.colFlag & MysqlType.FIELD_FLAG_UNSIGNED) > 0); + } + + public boolean isZeroFill() { + return ((this.colFlag & MysqlType.FIELD_FLAG_ZEROFILL) > 0); + } + + @Override + public String toString() { + try { + StringBuilder asString = new StringBuilder(); + asString.append(super.toString()); + asString.append("["); + asString.append("dbName="); + asString.append(this.getDatabaseName()); + asString.append(",tableName="); + asString.append(this.getTableName()); + asString.append(",originalTableName="); + asString.append(this.getOriginalTableName()); + asString.append(",columnName="); + asString.append(this.getName()); + asString.append(",originalColumnName="); + asString.append(this.getOriginalName()); + asString.append(",mysqlType="); + asString.append(getMysqlTypeId()); + asString.append("("); + MysqlType ft = getMysqlType(); + if (ft.equals(MysqlType.UNKNOWN)) { + asString.append(" Unknown MySQL Type # "); + asString.append(getMysqlTypeId()); + } else { + asString.append("FIELD_TYPE_"); + asString.append(ft.getName()); + } + asString.append(")"); + asString.append(",sqlType="); + asString.append(ft.getJdbcType()); + asString.append(",flags="); + + if (isAutoIncrement()) { + asString.append(" AUTO_INCREMENT"); + } + + if (isPrimaryKey()) { + asString.append(" PRIMARY_KEY"); + } + + if (isUniqueKey()) { + asString.append(" UNIQUE_KEY"); + } + + if (isBinary()) { + asString.append(" BINARY"); + } + + if (isBlob()) { + asString.append(" BLOB"); + } + + if (isMultipleKey()) { + asString.append(" MULTI_KEY"); + } + + if (isUnsigned()) { + asString.append(" UNSIGNED"); + } + + if (isZeroFill()) { + asString.append(" ZEROFILL"); + } + + asString.append(", charsetIndex="); + asString.append(this.collationIndex); + asString.append(", charsetName="); + asString.append(this.encoding); + + asString.append("]"); + + return asString.toString(); + } catch (Throwable t) { + return super.toString() + "[]"; + } + } + + public boolean isSingleBit() { + return (this.length <= 1); + } + + public boolean getValueNeedsQuoting() { + switch (this.mysqlType) { + case BIGINT: + case BIGINT_UNSIGNED: + case BIT: + case DECIMAL: + case DECIMAL_UNSIGNED: + case DOUBLE: + case DOUBLE_UNSIGNED: + case INT: + case INT_UNSIGNED: + case MEDIUMINT: + case MEDIUMINT_UNSIGNED: + case FLOAT: + case FLOAT_UNSIGNED: + case SMALLINT: + case SMALLINT_UNSIGNED: + case TINYINT: + case TINYINT_UNSIGNED: + return false; + default: + return true; + } + } + + public int getCollationIndex() { + return this.collationIndex; + } + + public MysqlType getMysqlType() { + return this.mysqlType; + } + + public void setMysqlType(MysqlType mysqlType) { + this.mysqlType = mysqlType; + } + + public short getFlags() { + return this.colFlag; + } + + public void setFlags(short colFlag) { + this.colFlag = colFlag; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/result/Row.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/result/Row.java new file mode 100644 index 0000000..e059947 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/result/Row.java @@ -0,0 +1,108 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import com.mysql.cj.Messages; +import com.mysql.cj.exceptions.CJOperationNotSupportedException; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.protocol.ColumnDefinition; +import com.mysql.cj.protocol.ProtocolEntity; +import com.mysql.cj.protocol.ValueDecoder; + +public interface Row extends ProtocolEntity { + /** + * Retrieve a value for the given column. This is the main facility to access values from the Row + * involving {@link ValueDecoder} and {@link ValueFactory} chain. Metadata must be set via + * Row constructor or {@link #setMetadata(ColumnDefinition)} call before calling this method to allow + * correct columnIndex boundaries check and data type recognition. + * + * @param + * type to decode to + * @param columnIndex + * index of column to retrieve value from (0-indexed, not JDBC 1-indexed) + * @param vf + * value factory used to create the return value after decoding + * @return The return value from the value factory + */ + T getValue(int columnIndex, ValueFactory vf); + + /** + * Set metadata to enable getValue functionality. + * + * @param columnDefinition + * {@link ColumnDefinition} + * @return {@link Row} + */ + default Row setMetadata(ColumnDefinition columnDefinition) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, Messages.getString("OperationNotSupportedException.0")); + } + + /** + * Returns the value at the given column as a byte array. + * The bytes represent the raw values returned by the server. + * + * @param columnIndex + * index of column (starting at 0) to return from. + * @return the value for the given column; if the value is SQL NULL, the value returned is null + */ + default byte[] getBytes(int columnIndex) { + // TODO check that "if the value is SQL NULL, the value returned is null" is correctly implemented + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, Messages.getString("OperationNotSupportedException.0")); + } + + /** + * Sets the given byte array as a raw column value (only works currently with ByteArrayRow). + * + * @param columnIndex + * index of the column (starting at 0) to set to. + * @param value + * the (raw) value to set + */ + default void setBytes(int columnIndex, byte[] value) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, Messages.getString("OperationNotSupportedException.0")); + } + + /** + * Check whether a column is NULL and update the 'wasNull' status. + * + * @param columnIndex + * of the column value (starting at 0) to check. + * + * @return true if the column value is NULL, false if not. + */ + boolean getNull(int columnIndex); + + /** + * Was the last value retrieved a NULL value? + * + * @return true if the last retrieved value was NULL. + */ + boolean wasNull(); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/result/RowList.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/result/RowList.java new file mode 100644 index 0000000..9ce8924 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/result/RowList.java @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.util.Iterator; + +import com.mysql.cj.Messages; +import com.mysql.cj.exceptions.CJOperationNotSupportedException; +import com.mysql.cj.exceptions.ExceptionFactory; + +/** + * A list of {@link Row}s. + */ +public interface RowList extends Iterator { + + /** + * What's returned for the size of a row list when its size can not be + * determined. + */ + public static final int RESULT_SET_SIZE_UNKNOWN = -1; + + /** + * Optionally iterate backwards on the list. + * + * @return {@link Row} + */ + default Row previous() { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, Messages.getString("OperationNotSupportedException.0")); + } + + /** + * Optionally retrieve Row at index n. + * + * Only works on non dynamic row lists. + * + * @param n + * row number + * @return {@link Row} + */ + default Row get(int n) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, Messages.getString("OperationNotSupportedException.0")); + } + + /** + * Returns the current position. + * + * @return the current row number + */ + default int getPosition() { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, Messages.getString("OperationNotSupportedException.0")); + } + + /** + * Only works on non dynamic row lists. + * + * @return the size of this row list + */ + default int size() { + return RESULT_SET_SIZE_UNKNOWN; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/result/ValueFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/result/ValueFactory.java new file mode 100644 index 0000000..c656bdc --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/result/ValueFactory.java @@ -0,0 +1,90 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.math.BigDecimal; +import java.math.BigInteger; + +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.protocol.InternalDate; +import com.mysql.cj.protocol.InternalTime; +import com.mysql.cj.protocol.InternalTimestamp; + +/** + * A class implements the ValueFactory<T> interface to create value instances from intermediate forms. + *

+ * A ValueFactory implementation is responsible for creating instance of a single type, supplying a value for the type parameter T. If an + * instance cannot be created from the intermediate form, an {@link java.lang.UnsupportedOperationException} can be thrown. + * + * @param + * value type + * + * @since 6.0 + */ +public interface ValueFactory { + + void setPropertySet(PropertySet pset); + + T createFromDate(InternalDate idate); + + T createFromTime(InternalTime it); + + T createFromTimestamp(InternalTimestamp its); + + T createFromDatetime(InternalTimestamp its); + + T createFromLong(long l); + + T createFromBigInteger(BigInteger i); + + T createFromDouble(double d); + + T createFromBigDecimal(BigDecimal d); + + T createFromBytes(byte[] bytes, int offset, int length, Field f); + + T createFromBit(byte[] bytes, int offset, int length); + + T createFromYear(long l); + + /** + * Create result value from intermediate null value. + * + * @return T object + */ + T createFromNull(); + + /** + * Get the actual class name of T parameter. + * + * @return class name + */ + String getTargetTypeName(); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/Base64Decoder.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/Base64Decoder.java new file mode 100644 index 0000000..3eb6b30 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/Base64Decoder.java @@ -0,0 +1,97 @@ +/* + * Copyright (c) 2014, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.util; + +/** + * This decoder implements standard Base64 decoding except it allows and silently ignores non-base64 input characters (spaces, line breaks etc) + * + * Note: Java 6+ provide standard decoders + */ +public class Base64Decoder { + + /* + * -1 means non-base64 character + * -2 means padding + */ + private static byte[] decoderMap = new byte[] { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, + -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -2, -1, -1, + -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28, 29, 30, 31, + 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1 }; + + public static class IntWrapper { + public int value; + + public IntWrapper(int value) { + this.value = value; + } + } + + private static byte getNextValidByte(byte[] in, IntWrapper pos, int maxPos) { + while (pos.value <= maxPos) { + if (in[pos.value] >= 0 && decoderMap[in[pos.value]] >= 0) { + return in[pos.value++]; + } + pos.value++; + } + // padding if reached max position + return '='; + } + + public static byte[] decode(byte[] in, int pos, int length) { + IntWrapper offset = new Base64Decoder.IntWrapper(pos); + byte[] sestet = new byte[4]; + + int outLen = (length * 3) / 4; // over-estimated if non-base64 characters present + byte[] octet = new byte[outLen]; + int octetId = 0; + + int maxPos = offset.value + length - 1; + while (offset.value <= maxPos) { + sestet[0] = decoderMap[getNextValidByte(in, offset, maxPos)]; + sestet[1] = decoderMap[getNextValidByte(in, offset, maxPos)]; + sestet[2] = decoderMap[getNextValidByte(in, offset, maxPos)]; + sestet[3] = decoderMap[getNextValidByte(in, offset, maxPos)]; + + if (sestet[1] != -2) { + octet[octetId++] = (byte) ((sestet[0] << 2) | (sestet[1] >>> 4)); + } + if (sestet[2] != -2) { + octet[octetId++] = (byte) (((sestet[1] & 0xf) << 4) | (sestet[2] >>> 2)); + } + if (sestet[3] != -2) { + octet[octetId++] = (byte) (((sestet[2] & 3) << 6) | sestet[3]); + } + } + // return real-length value + byte[] out = new byte[octetId]; + System.arraycopy(octet, 0, out, 0, octetId); + return out; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/DataTypeUtil.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/DataTypeUtil.java new file mode 100644 index 0000000..4602dc0 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/DataTypeUtil.java @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2018, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.util; + +/** + * Utilities to manipulate internal data type formats. + */ +public class DataTypeUtil { + + /** + * Interpret a BIT value as a long. + * + * @param bytes + * byte buffer + * @param offset + * offset in buffer + * @param length + * number of bytes to use + * @return long value + */ + public static long bitToLong(byte[] bytes, int offset, int length) { + long valueAsLong = 0; + for (int i = 0; i < length; i++) { + valueAsLong = valueAsLong << 8 | bytes[offset + i] & 0xff; + } + return valueAsLong; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/DnsSrv.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/DnsSrv.java new file mode 100644 index 0000000..f3cca66 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/DnsSrv.java @@ -0,0 +1,156 @@ +/* + * Copyright (c) 2019, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.util; + +import java.util.ArrayList; +import java.util.List; +import java.util.Properties; +import java.util.Random; +import java.util.stream.Collectors; + +import javax.naming.Context; +import javax.naming.NamingException; +import javax.naming.directory.Attribute; +import javax.naming.directory.Attributes; +import javax.naming.directory.DirContext; +import javax.naming.directory.InitialDirContext; + +public class DnsSrv { + public static class SrvRecord implements Comparable { + private final int priority; + private final int weight; + private final int port; + private final String target; + + public static SrvRecord buildFrom(String srvLine) { + String[] srvParts = srvLine.split("\\s+"); + if (srvParts.length == 4) { + int priority = Integer.parseInt(srvParts[0]); + int weight = Integer.parseInt(srvParts[1]); + int port = Integer.parseInt(srvParts[2]); + String target = srvParts[3].replaceFirst("\\.$", ""); + return new SrvRecord(priority, weight, port, target); + } + return null; + } + + public SrvRecord(int priority, int weight, int port, String target) { + this.priority = priority; + this.weight = weight; + this.port = port; + this.target = target; + } + + public int getPriority() { + return this.priority; + } + + public int getWeight() { + return this.weight; + } + + public int getPort() { + return this.port; + } + + public String getTarget() { + return this.target; + } + + @Override + public String toString() { + return String.format("{\"Priority\": %d, \"Weight\": %d, \"Port\": %d, \"Target\": \"%s\"}", getPriority(), getWeight(), getPort(), getTarget()); + } + + @Override + public int compareTo(SrvRecord o) { + int priorityDiff = getPriority() - o.getPriority(); + return priorityDiff == 0 ? getWeight() - o.getWeight() : priorityDiff; + } + } + + public static List lookupSrvRecords(String serviceName) throws NamingException { + List srvRecords = new ArrayList<>(); + + Properties environment = new Properties(); + environment.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.dns.DnsContextFactory"); + DirContext context = new InitialDirContext(environment); + Attributes dnsEntries = context.getAttributes(serviceName, new String[] { "SRV" }); + if (dnsEntries != null) { + Attribute hosts = dnsEntries.get("SRV"); + if (hosts != null) { + for (int i = 0; i < hosts.size(); i++) { + srvRecords.add(SrvRecord.buildFrom((String) hosts.get(i))); + } + } + } + + return sortSrvRecords(srvRecords); + } + + /** + * Sort a list of DNS SRV records according to the sorting rules described in rfc2782. + * + * @param srvRecords + * the list of {@link SrvRecord}s to sort. + * @return + * a new list of sorted {@link SrvRecord}s. + */ + public static List sortSrvRecords(List srvRecords) { + // Sort srv records by their natural order, i.e., first by priority then by weight. + List srvRecordsSortedNatural = srvRecords.stream().sorted().collect(Collectors.toList()); + + // Sort records with equal priority by weight using a categorical distribution. + Random random = new Random(System.nanoTime()); + List srvRecordsSortedRfc2782 = new ArrayList<>(); + + List priorities = srvRecordsSortedNatural.stream().map(SrvRecord::getPriority).distinct().collect(Collectors.toList()); + for (Integer priority : priorities) { + List srvRecordsSamePriority = srvRecordsSortedNatural.stream().filter(s -> s.getPriority() == priority).collect(Collectors.toList()); + while (srvRecordsSamePriority.size() > 1) { + int recCount = srvRecordsSamePriority.size(); + int sumOfWeights = 0; + int[] weights = new int[recCount]; + for (int i = 0; i < recCount; i++) { + sumOfWeights += srvRecordsSamePriority.get(i).getWeight(); + weights[i] = sumOfWeights; + } + int selection = random.nextInt(sumOfWeights + 1); + int pos = 0; + for (; pos < recCount && weights[pos] < selection; pos++) { + } + srvRecordsSortedRfc2782.add(srvRecordsSamePriority.remove(pos)); + } + srvRecordsSortedRfc2782.add(srvRecordsSamePriority.get(0)); + } + + return srvRecordsSortedRfc2782; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/EscapeTokenizer.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/EscapeTokenizer.java new file mode 100644 index 0000000..48af210 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/EscapeTokenizer.java @@ -0,0 +1,190 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.util; + +/** + * EscapeTokenizer breaks up an SQL statement into SQL and escape code parts. + */ +public class EscapeTokenizer { + private static final char CHR_ESCAPE = '\\'; + private static final char CHR_SGL_QUOTE = '\''; + private static final char CHR_DBL_QUOTE = '"'; + private static final char CHR_LF = '\n'; + private static final char CHR_CR = '\r'; + private static final char CHR_COMMENT = '-'; + private static final char CHR_BEGIN_TOKEN = '{'; + private static final char CHR_END_TOKEN = '}'; + private static final char CHR_VARIABLE = '@'; + + private String source = null; + private int sourceLength = 0; + private int pos = 0; + + private boolean emittingEscapeCode = false; + private boolean sawVariableUse = false; + private int bracesLevel = 0; + private boolean inQuotes = false; + private char quoteChar = 0; + + /** + * Creates a new EscapeTokenizer object. + * + * @param source + * the string to tokenize + */ + public EscapeTokenizer(String source) { + this.source = source; + this.sourceLength = source.length(); + this.pos = 0; + } + + /** + * Does this tokenizer have more tokens available? + * + * @return if this tokenizer has more tokens available + */ + public synchronized boolean hasMoreTokens() { + return (this.pos < this.sourceLength); + } + + /** + * Returns the next token + * + * @return the next token. + */ + public synchronized String nextToken() { + StringBuilder tokenBuf = new StringBuilder(); + boolean backslashEscape = false; + + if (this.emittingEscapeCode) { + // Previous token ended at the beginning of an escape code, so this token must start with '{' + tokenBuf.append("{"); + this.emittingEscapeCode = false; + } + + for (; this.pos < this.sourceLength; this.pos++) { + char c = this.source.charAt(this.pos); + + // process escape char: (\) + if (c == CHR_ESCAPE) { + tokenBuf.append(c); + backslashEscape = !backslashEscape; + continue; + } + + // process quotes: ('|") + if ((c == CHR_SGL_QUOTE || c == CHR_DBL_QUOTE) && !backslashEscape) { + tokenBuf.append(c); + if (this.inQuotes) { + if (c == this.quoteChar) { + // look ahead for doubled quote + if ((this.pos + 1 < this.sourceLength) && (this.source.charAt(this.pos + 1) == this.quoteChar)) { + tokenBuf.append(c); + this.pos++; // consume following char '\'' or '"' + } else { + this.inQuotes = false; + } + } + } else { + this.inQuotes = true; + this.quoteChar = c; + } + continue; + } + + // process new line: (\n|\r) + if ((c == CHR_LF) || (c == CHR_CR)) { + tokenBuf.append(c); + backslashEscape = false; + continue; + } + + if (!this.inQuotes && !backslashEscape) { + // process comments: (--) + if (c == CHR_COMMENT) { + tokenBuf.append(c); + // look ahead for double hyphen + if ((this.pos + 1 < this.sourceLength) && (this.source.charAt(this.pos + 1) == CHR_COMMENT)) { + // consume following chars until new line or end of string + while (++this.pos < this.sourceLength && c != CHR_LF && c != CHR_CR) { + c = this.source.charAt(this.pos); + tokenBuf.append(c); + } + this.pos--; + } + continue; + } + + // process begin token: ({) + if (c == CHR_BEGIN_TOKEN) { + this.bracesLevel++; + if (this.bracesLevel == 1) { + this.emittingEscapeCode = true; + this.pos++; // consume char '{' before returning + return tokenBuf.toString(); + } + tokenBuf.append(c); + continue; + } + + // process end token: (}) + if (c == CHR_END_TOKEN) { + tokenBuf.append(c); + this.bracesLevel--; + if (this.bracesLevel == 0) { + this.pos++; // consume char '}' before returning + return tokenBuf.toString(); + } + continue; + } + + // detect variable usage: (@) + if (c == CHR_VARIABLE) { + this.sawVariableUse = true; + } + } + + tokenBuf.append(c); + backslashEscape = false; + } + + return tokenBuf.toString(); + } + + /** + * Returns true if a variable reference was found. Note that this information isn't accurate until finishing to + * process all tokens from source String. It also can't be used as per token basis. + * + * @return true if a variable reference was found. + */ + public boolean sawVariableUse() { + return this.sawVariableUse; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/LRUCache.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/LRUCache.java new file mode 100644 index 0000000..31b37c5 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/LRUCache.java @@ -0,0 +1,48 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.util; + +import java.util.LinkedHashMap; +import java.util.Map.Entry; + +public class LRUCache extends LinkedHashMap { + private static final long serialVersionUID = 1L; + protected int maxElements; + + public LRUCache(int maxSize) { + super(maxSize, 0.75F, true); + this.maxElements = maxSize; + } + + @Override + protected boolean removeEldestEntry(Entry eldest) { + return (size() > this.maxElements); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/LazyString.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/LazyString.java new file mode 100644 index 0000000..142a3a4 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/LazyString.java @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.util; + +import java.util.function.Supplier; + +/** + * A lazy string that can take a byte buffer and encoding and interpret it as a string if/when requested. The string is cached and saved for any further + * requests. "NULL" values can be represented by a 0-len string or a null passed to LazyString(String). + */ +public class LazyString implements Supplier { + private String string; // the string, if one has been created + private byte[] buffer; + private int offset; + private int length; + private String encoding; + + public LazyString(String string) { + // convenience for wrapping + this.string = string; + } + + public LazyString(byte[] buffer, int offset, int length, String encoding) { + this.buffer = buffer; + this.offset = offset; + this.length = length; + this.encoding = encoding; + } + + public LazyString(byte[] buffer, int offset, int length) { + this.buffer = buffer; + this.offset = offset; + this.length = length; + } + + private String createAndCacheString() { + if (this.length > 0) { + this.string = this.encoding == null ? StringUtils.toString(this.buffer, this.offset, this.length) + : StringUtils.toString(this.buffer, this.offset, this.length, this.encoding); + } + // this can be NULL for 0-len strings + return this.string; + } + + @Override + public String toString() { + if (this.string != null) { + return this.string; + } + return createAndCacheString(); + } + + public int length() { + if (this.string != null) { + return this.string.length(); + } + return this.length; + } + + @Override + public String get() { + return toString(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/LogUtils.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/LogUtils.java new file mode 100644 index 0000000..c5ce373 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/LogUtils.java @@ -0,0 +1,67 @@ +/* + * Copyright (c) 2005, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.util; + +import com.mysql.cj.conf.PropertyDefinitions; + +public class LogUtils { + + public static final String CALLER_INFORMATION_NOT_AVAILABLE = "Caller information not available"; + + private static final String LINE_SEPARATOR = System.getProperty(PropertyDefinitions.SYSP_line_separator); + + private static final int LINE_SEPARATOR_LENGTH = LINE_SEPARATOR.length(); + + public static String findCallingClassAndMethod(Throwable t) { + String stackTraceAsString = Util.stackTraceToString(t); + + String callingClassAndMethod = CALLER_INFORMATION_NOT_AVAILABLE; + + int endInternalMethods = Math.max(Math.max(stackTraceAsString.lastIndexOf("com.mysql.cj"), stackTraceAsString.lastIndexOf("com.mysql.cj.core")), + stackTraceAsString.lastIndexOf("com.mysql.cj.jdbc")); + + if (endInternalMethods != -1) { + int endOfLine = stackTraceAsString.indexOf(LINE_SEPARATOR, endInternalMethods); + + if (endOfLine != -1) { + int nextEndOfLine = stackTraceAsString.indexOf(LINE_SEPARATOR, endOfLine + LINE_SEPARATOR_LENGTH); + callingClassAndMethod = nextEndOfLine != -1 ? stackTraceAsString.substring(endOfLine + LINE_SEPARATOR_LENGTH, nextEndOfLine) + : stackTraceAsString.substring(endOfLine + LINE_SEPARATOR_LENGTH); + } + } + + if (!callingClassAndMethod.startsWith("\tat ") && !callingClassAndMethod.startsWith("at ")) { + return "at " + callingClassAndMethod; + } + + return callingClassAndMethod; + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/PerVmServerConfigCacheFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/PerVmServerConfigCacheFactory.java new file mode 100644 index 0000000..241daf0 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/PerVmServerConfigCacheFactory.java @@ -0,0 +1,70 @@ +/* + * Copyright (c) 2013, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.util; + +import java.util.Map; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; + +import com.mysql.cj.CacheAdapter; +import com.mysql.cj.CacheAdapterFactory; + +public class PerVmServerConfigCacheFactory implements CacheAdapterFactory> { + static final ConcurrentHashMap> serverConfigByUrl = new ConcurrentHashMap<>(); + + private static final CacheAdapter> serverConfigCache = new CacheAdapter>() { + + public Map get(String key) { + return serverConfigByUrl.get(key); + } + + public void put(String key, Map value) { + serverConfigByUrl.putIfAbsent(key, value); + } + + public void invalidate(String key) { + serverConfigByUrl.remove(key); + } + + public void invalidateAll(Set keys) { + for (String key : keys) { + serverConfigByUrl.remove(key); + } + } + + public void invalidateAll() { + serverConfigByUrl.clear(); + } + }; + + public CacheAdapter> getInstance(Object syncMutex, String url, int cacheMaxSize, int maxKeySize) { + return serverConfigCache; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/SaslPrep.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/SaslPrep.java new file mode 100644 index 0000000..e043d66 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/SaslPrep.java @@ -0,0 +1,349 @@ +/* + * Copyright (c) 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.util; + +import java.text.Normalizer; +import java.text.Normalizer.Form; + +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.WrongArgumentException; + +/** + * Implementation for SASLprep: Stringprep Profile for User Names and Passwords, as specified in RFC 4013. + * + * @see RFC 3454 + */ +public class SaslPrep { + /** + * The type of string usage regarding the support for unassigned code points as described in RFC + * 3454, Section 7. + */ + public enum StringType { + /** + * Stored strings using the profile MUST NOT contain any unassigned code points. + */ + STORED, + /** + * Queries for matching strings MAY contain unassigned code points. + */ + QUERY; + } + + /** + * Prepares the given string by applying the "SASLprep" profile of the "stringprep" algorithm. + * + * @param str + * the string to prepare. + * @param sType + * the type of preparation with regard to the support for unassigned code points. + * + * @return + * the prepared version of the given string. + * @see RFC 4013 + * @see RFC 3454 + */ + public static String prepare(String str, StringType sType) { + if (str.length() == 0) { + return str; + } + + StringBuilder sb = new StringBuilder(str.length()); + + // 2.1. Mapping. + for (char chr : str.toCharArray()) { + if (isNonAsciiSpaceChar(chr)) { + sb.append(' '); + } else if (!isMappeableToNothing(chr)) { + sb.append(chr); + } + } + + // 2.2. Normalization. + String preparedStr = normalizeKc(sb); + + // 2.3. Prohibited Output & 2.4. Bidirectional Characters & 2.5. Unassigned Code Points. + boolean startsWithRAndAlCat = isBidiRAndAlCat(preparedStr.codePointAt(0)); + boolean endsWithRAndAlCat = isBidiRAndAlCat( + preparedStr.codePointAt(preparedStr.length() - (Character.isLowSurrogate(preparedStr.charAt(preparedStr.length() - 1)) ? 2 : 1))); + boolean containsRAndAlCat = startsWithRAndAlCat || endsWithRAndAlCat; + boolean containsLCat = false; + for (int i = 0, ni; i < preparedStr.length(); i = ni) { + char chr = preparedStr.charAt(i); + int cp = preparedStr.codePointAt(i); + ni = i + Character.charCount(cp); + + // 2.3. Prohibited Output. + if (isProhibited(chr, cp)) { + throw ExceptionFactory.createException(WrongArgumentException.class, "Prohibited character at position " + i + "."); + } + + // 2.4. Bidirectional Characters. + // (Already covered: MUST be prohibited - change display properties or are deprecated.) + // RFC 3454, Section 5.8. + if (!containsRAndAlCat) { + containsRAndAlCat = isBidiRAndAlCat(cp); + } + if (!containsLCat) { + containsLCat = isBidiLCat(cp); + } + if (containsRAndAlCat && containsLCat) { + throw ExceptionFactory.createException(WrongArgumentException.class, "Cannot contain both RandALCat characters and LCat characters."); + } + if (ni >= preparedStr.length() && containsRAndAlCat && (!startsWithRAndAlCat || !endsWithRAndAlCat)) { + throw ExceptionFactory.createException(WrongArgumentException.class, + "Cannot contain RandALCat characters and not start and end with RandALCat characters."); + } + + // 2.5. Unassigned Code Points. + if (sType == StringType.STORED && isUnassigned(cp)) { + throw ExceptionFactory.createException(WrongArgumentException.class, "Unassigned character at position " + i + "."); + } + } + + return preparedStr; + } + + /** + * Mapping: non-ASCII space characters [StringPrep, C.1.2] that can be mapped to SPACE + * (U+0020). + * + * @param chr + * the character to check. + * @return + * true if the character is one of the non-ASCII space characters, false otherwise. + */ + private static boolean isNonAsciiSpaceChar(char chr) { + return chr == '\u00A0' || chr == '\u1680' || chr >= '\u2000' && chr <= '\u200B' || chr == '\u202F' || chr == '\u205F' || chr == '\u3000'; + } + + /** + * Mapping: the "commonly mapped to nothing" characters [StringPrep, B.1] that can be mapped + * to nothing. + * + * @param chr + * the character to check. + * @return + * true if the character is one of the "commonly mapped to nothing" characters, false otherwise. + */ + private static boolean isMappeableToNothing(char chr) { + return chr == '\u00AD' || chr == '\u034F' || chr == '\u1806' || chr >= '\u180B' && chr <= '\u180D' || chr >= '\u200B' && chr <= '\u200D' + || chr == '\u2060' || chr >= '\uFE00' && chr <= '\uFE0F' || chr == '\uFEFF'; + } + + /** + * Normalization: Unicode normalization form KC. + * + * @param str + * the string to be normalized. + * @return + * a normalized version of the given string by the rules of the Unicode normalization form KC. + */ + private static String normalizeKc(CharSequence str) { + return Normalizer.normalize(str, Form.NFKC); + } + + /** + * Checks if the given character is one of the prohibited characters under the "SASLprep Profile" rules. + * + * @param chr + * the character to check. + * @param cp + * the code point of the character to check. + * @return + * true if the character is prohibited according to the profile rules, false otherwise. + * @see RFC 4013, Section 2.3 + */ + private static boolean isProhibited(char chr, int cp) { + return /* already covered: isNonAsciiSpaceChar(chr) || */ isAsciiControlCharacter(chr) || isNonAsciiControlCharacter(cp) || isPrivateUseCharacter(cp) + || isNonCharacterCodePoint(cp) || isSurrogateCode(chr) || isInappropriateForPlainTextCharacter(chr) + || isInappropriateForCanonicalRepresentationCharacter(chr) || isChangeDisplayPropertiesOrDeprecatedCharacter(chr) || isTaggingCharacter(cp); + } + + /** + * Prohibited Output: ASCII control characters [StringPrep, C.2.1]. + * + * @param chr + * the character to check. + * @return + * true if the character is one of the ASCII control characters, false otherwise. + */ + private static boolean isAsciiControlCharacter(char chr) { + return chr <= '\u001F' || chr == '\u007F'; + } + + /** + * Prohibited Output: non-ASCII control characters [StringPrep, C.2.2]. + * + * @param cp + * the code point of the character to check. + * @return + * true if the character is one of the non-ASCII control characters, false otherwise. + */ + private static boolean isNonAsciiControlCharacter(int cp) { + return cp >= 0x0080 && cp <= 0x009F || cp == 0x06DD || cp == 0x070F || cp == 0x180E || cp == 0x200C || cp == 0x200D || cp == 0x2028 || cp == 0x2029 + || cp >= 0x2060 && cp <= 0x2063 || cp >= 0x206A && cp <= 0x206F || cp == 0xFEFF || cp >= 0xFFF9 && cp <= 0xFFFC + || cp >= 0x1D173 && cp <= 0x1D17A; + } + + /** + * Prohibited Output: private use characters [StringPrep, C.3]. + * + * @param cp + * the code point of the character to check. + * @return + * true if the character is one of the private use characters, false otherwise. + */ + private static boolean isPrivateUseCharacter(int cp) { + return cp >= 0xE000 && cp <= 0xF8FF || cp >= 0xF0000 && cp <= 0xFFFFD || cp >= 0x100000 && cp <= 0x10FFFD; + } + + /** + * Prohibited Output: non-character code points [StringPrep, C.4]. + * + * @param cp + * the code point of the character to check. + * @return + * true if the character is one of the non-character code points, false otherwise. + */ + private static boolean isNonCharacterCodePoint(int cp) { + return cp >= 0xFDD0 && cp <= 0xFDEF || cp >= 0xFFFE && cp <= 0xFFFF || cp >= 0x1FFFE && cp <= 0x1FFFF || cp >= 0x2FFFE && cp <= 0x2FFFF + || cp >= 0x3FFFE && cp <= 0x3FFFF || cp >= 0x4FFFE && cp <= 0x4FFFF || cp >= 0x5FFFE && cp <= 0x5FFFF || cp >= 0x6FFFE && cp <= 0x6FFFF + || cp >= 0x7FFFE && cp <= 0x7FFFF || cp >= 0x8FFFE && cp <= 0x8FFFF || cp >= 0x9FFFE && cp <= 0x9FFFF || cp >= 0xAFFFE && cp <= 0xAFFFF + || cp >= 0xBFFFE && cp <= 0xBFFFF || cp >= 0xCFFFE && cp <= 0xCFFFF || cp >= 0xDFFFE && cp <= 0xDFFFF || cp >= 0xEFFFE && cp <= 0xEFFFF + || cp >= 0xFFFFE && cp <= 0xFFFFF || cp >= 0x10FFFE && cp <= 0x10FFFF; + } + + /** + * Prohibited Output: surrogate code points [StringPrep, C.5]. + * + * @param chr + * the character to check. + * @return + * true if the character is one of the surrogate code points, false otherwise. + */ + private static boolean isSurrogateCode(char chr) { + return chr >= '\uD800' && chr <= '\uDFFF'; + } + + /** + * Prohibited Output: inappropriate for plain text characters [StringPrep, C.6]. + * + * @param chr + * the character to check. + * @return + * true if the character is one of the inappropriate for plain text characters, false otherwise. + */ + private static boolean isInappropriateForPlainTextCharacter(char chr) { + return chr == '\uFFF9' || chr >= '\uFFFA' && chr <= '\uFFFD'; + } + + /** + * Prohibited Output: inappropriate for canonical representation characters [StringPrep, + * C.7]. + * + * @param chr + * the character to check. + * @return + * true if the character is one of the inappropriate for canonical representation characters, false otherwise. + */ + private static boolean isInappropriateForCanonicalRepresentationCharacter(char chr) { + return chr >= '\u2FF0' && chr <= '\u2FFB'; + } + + /** + * Prohibited Output: change display properties or deprecated characters [StringPrep, C.8]. + * + * @param chr + * the character to check. + * @return + * true if the character is one of the change display properties or deprecated characters, false otherwise. + */ + private static boolean isChangeDisplayPropertiesOrDeprecatedCharacter(char chr) { + return chr == '\u0340' || chr == '\u0341' || chr == '\u200E' || chr == '\u200F' || chr >= '\u202A' && chr <= '\u202E' + || chr >= '\u206A' && chr <= '\u206F'; + } + + /** + * Prohibited Output: tagging characters [StringPrep, C.9]. + * + * @param cp + * the code point of the character to check. + * @return + * true if the character is one of the tagging characters, false otherwise. + */ + private static boolean isTaggingCharacter(int cp) { + return cp == 0xE0001 || cp >= 0xE0020 && cp <= 0xE007F; + } + + /** + * Bidirectional Characters: RandALCat characters. + * See also RFC 3454, Section 6 + * + * @param cp + * the code point of the character to check. + * @return + * true if the character is one of the RandALCat characters, false otherwise. + */ + private static boolean isBidiRAndAlCat(int cp) { + byte dir = Character.getDirectionality(cp); + return dir == Character.DIRECTIONALITY_RIGHT_TO_LEFT || dir == Character.DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC; + } + + /** + * Bidirectional Characters: LCat characters. + * See also RFC 3454, Section 6 + * + * @param cp + * the code point of the character to check. + * @return + * true if the character is one of the LCat characters, false otherwise. + */ + private static boolean isBidiLCat(int cp) { + byte dir = Character.getDirectionality(cp); + return dir == Character.DIRECTIONALITY_LEFT_TO_RIGHT; + } + + /** + * Unassigned Code Points: list of unassigned code points. + * See also RFC 3454, Section 7. + * + *

+ * Note that this implementation does not check exactly the unassigned code points as specified in the RFC since it is based on Java's Unicode support, + * which is updated regularly while the specification is based on a static list of code points. This should have no major impact, though. + * + * @param cp + * the code point of the character to check. + * @return + * true if the character is unassigned, false otherwise. + */ + private static boolean isUnassigned(int cp) { + return !Character.isDefined(cp); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/SequentialIdLease.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/SequentialIdLease.java new file mode 100644 index 0000000..39d5d7d --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/SequentialIdLease.java @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2019, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.util; + +import java.util.Iterator; +import java.util.Set; +import java.util.TreeSet; + +public class SequentialIdLease { + private Set sequentialIdsLease = new TreeSet<>(); + + /** + * Finds and allocates the first available sequential id. + * + * @return the next free sequential id. + */ + public int allocateSequentialId() { + int nextSequentialId = 0; + for (Iterator it = this.sequentialIdsLease.iterator(); it.hasNext() && nextSequentialId + 1 == it.next(); nextSequentialId++) { + // Find the first free sequential id. + } + this.sequentialIdsLease.add(++nextSequentialId); + return nextSequentialId; + } + + /** + * Frees the given sequential id so that it can be reused. + * + * @param sequentialId + * the sequential id to release + */ + public void releaseSequentialId(int sequentialId) { + this.sequentialIdsLease.remove(sequentialId); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/StringUtils.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/StringUtils.java new file mode 100644 index 0000000..be18706 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/StringUtils.java @@ -0,0 +1,2080 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.util; + +import java.io.IOException; +import java.io.StringReader; +import java.io.UnsupportedEncodingException; +import java.nio.ByteBuffer; +import java.nio.CharBuffer; +import java.nio.charset.Charset; +import java.nio.charset.UnsupportedCharsetException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.EnumSet; +import java.util.List; +import java.util.Set; +import java.util.UUID; +import java.util.stream.Collectors; + +import com.mysql.cj.Messages; +import com.mysql.cj.ServerVersion; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.WrongArgumentException; + +/** + * Various utility methods for converting to/from byte arrays in the platform encoding + */ +public class StringUtils { + public enum SearchMode { + ALLOW_BACKSLASH_ESCAPE, SKIP_BETWEEN_MARKERS, SKIP_BLOCK_COMMENTS, SKIP_LINE_COMMENTS, SKIP_WHITE_SPACE; + } + + /* + * Convenience EnumSets for several SearchMode combinations + */ + + /** + * Full search mode: allow backslash escape, skip between markers, skip block comments, skip line comments and skip white space. + */ + public static final Set SEARCH_MODE__ALL = Collections.unmodifiableSet(EnumSet.allOf(SearchMode.class)); + + /** + * Search mode: skip between markers, skip block comments, skip line comments and skip white space. + */ + public static final Set SEARCH_MODE__MRK_COM_WS = Collections.unmodifiableSet( + EnumSet.of(SearchMode.SKIP_BETWEEN_MARKERS, SearchMode.SKIP_BLOCK_COMMENTS, SearchMode.SKIP_LINE_COMMENTS, SearchMode.SKIP_WHITE_SPACE)); + + /** + * Search mode: allow backslash escape, skip block comments, skip line comments and skip white space. + */ + public static final Set SEARCH_MODE__BSESC_COM_WS = Collections.unmodifiableSet( + EnumSet.of(SearchMode.ALLOW_BACKSLASH_ESCAPE, SearchMode.SKIP_BLOCK_COMMENTS, SearchMode.SKIP_LINE_COMMENTS, SearchMode.SKIP_WHITE_SPACE)); + + /** + * Search mode: allow backslash escape, skip between markers and skip white space. + */ + public static final Set SEARCH_MODE__BSESC_MRK_WS = Collections + .unmodifiableSet(EnumSet.of(SearchMode.ALLOW_BACKSLASH_ESCAPE, SearchMode.SKIP_BETWEEN_MARKERS, SearchMode.SKIP_WHITE_SPACE)); + + /** + * Search mode: skip block comments, skip line comments and skip white space. + */ + public static final Set SEARCH_MODE__COM_WS = Collections + .unmodifiableSet(EnumSet.of(SearchMode.SKIP_BLOCK_COMMENTS, SearchMode.SKIP_LINE_COMMENTS, SearchMode.SKIP_WHITE_SPACE)); + + /** + * Search mode: skip between markers and skip white space. + */ + public static final Set SEARCH_MODE__MRK_WS = Collections + .unmodifiableSet(EnumSet.of(SearchMode.SKIP_BETWEEN_MARKERS, SearchMode.SKIP_WHITE_SPACE)); + + /** + * Empty search mode. + */ + public static final Set SEARCH_MODE__NONE = Collections.unmodifiableSet(EnumSet.noneOf(SearchMode.class)); + + // length of MySQL version reference in comments of type '/*![00000] */' + private static final int NON_COMMENTS_MYSQL_VERSION_REF_LENGTH = 5; + + //private static final int BYTE_RANGE = (1 + Byte.MAX_VALUE) - Byte.MIN_VALUE; + + private static final int WILD_COMPARE_MATCH = 0; + private static final int WILD_COMPARE_CONTINUE_WITH_WILD = 1; + private static final int WILD_COMPARE_NO_MATCH = -1; + + static final char WILDCARD_MANY = '%'; + static final char WILDCARD_ONE = '_'; + static final char WILDCARD_ESCAPE = '\\'; + + private static final String VALID_ID_CHARS = "abcdefghijklmnopqrstuvwxyzABCDEFGHIGKLMNOPQRSTUVWXYZ0123456789$_#@"; + + /** + * Returns the given bytes as a hex and ascii dump (up to length bytes). + * + * @param byteBuffer + * the data to dump as hex + * @param length + * the number of bytes to print + * + * @return a hex and ascii dump + */ + public static String dumpAsHex(byte[] byteBuffer, int length) { + length = Math.min(length, byteBuffer.length); + StringBuilder fullOutBuilder = new StringBuilder(length * 4); + StringBuilder asciiOutBuilder = new StringBuilder(16); + + for (int p = 0, l = 0; p < length; l = 0) { // p: position in buffer (1..length); l: position in line (1..8) + for (; l < 8 && p < length; p++, l++) { + int asInt = byteBuffer[p] & 0xff; + if (asInt < 0x10) { + fullOutBuilder.append("0"); + } + fullOutBuilder.append(Integer.toHexString(asInt)).append(" "); + asciiOutBuilder.append(" ").append(asInt >= 0x20 && asInt < 0x7f ? (char) asInt : "."); + } + for (; l < 8; l++) { // if needed, fill remaining of last line with spaces + fullOutBuilder.append(" "); + } + fullOutBuilder.append(" ").append(asciiOutBuilder).append(System.lineSeparator()); + asciiOutBuilder.setLength(0); + } + return fullOutBuilder.toString(); + } + + /** + * Converts the given byte array into Hex String, stopping at given length. + * + * @param byteBuffer + * the byte array to convert + * @param length + * the number of bytes from the given array to convert + * @return + * a String containing the Hex representation of the given bytes + */ + public static String toHexString(byte[] byteBuffer, int length) { + length = Math.min(length, byteBuffer.length); + StringBuilder outputBuilder = new StringBuilder(length * 2); + for (int i = 0; i < length; i++) { + int asInt = byteBuffer[i] & 0xff; + if (asInt < 0x10) { + outputBuilder.append("0"); + } + outputBuilder.append(Integer.toHexString(asInt)); + } + return outputBuilder.toString(); + } + + private static boolean endsWith(byte[] dataFrom, String suffix) { + for (int i = 1; i <= suffix.length(); i++) { + int dfOffset = dataFrom.length - i; + int suffixOffset = suffix.length() - i; + if (dataFrom[dfOffset] != suffix.charAt(suffixOffset)) { + return false; + } + } + return true; + } + + /** + * Returns the first non-whitespace char, converted to upper case + * + * @param searchIn + * the string to search in + * + * @return the first non-whitespace character, upper cased. + */ + public static char firstNonWsCharUc(String searchIn) { + return firstNonWsCharUc(searchIn, 0); + } + + public static char firstNonWsCharUc(String searchIn, int startAt) { + if (searchIn == null) { + return 0; + } + + int length = searchIn.length(); + + for (int i = startAt; i < length; i++) { + char c = searchIn.charAt(i); + + if (!Character.isWhitespace(c)) { + return Character.toUpperCase(c); + } + } + + return 0; + } + + public static char firstAlphaCharUc(String searchIn, int startAt) { + if (searchIn == null) { + return 0; + } + + int length = searchIn.length(); + + for (int i = startAt; i < length; i++) { + char c = searchIn.charAt(i); + + if (Character.isLetter(c)) { + return Character.toUpperCase(c); + } + } + + return 0; + } + + /** + * Adds '+' to decimal numbers that are positive (MySQL doesn't understand + * them otherwise + * + * @param dString + * The value as a string + * + * @return String the string with a '+' added (if needed) + */ + public static String fixDecimalExponent(String dString) { + int ePos = dString.indexOf('E'); + + if (ePos == -1) { + ePos = dString.indexOf('e'); + } + + if (ePos != -1) { + if (dString.length() > (ePos + 1)) { + char maybeMinusChar = dString.charAt(ePos + 1); + + if (maybeMinusChar != '-' && maybeMinusChar != '+') { + StringBuilder strBuilder = new StringBuilder(dString.length() + 1); + strBuilder.append(dString.substring(0, ePos + 1)); + strBuilder.append('+'); + strBuilder.append(dString.substring(ePos + 1, dString.length())); + dString = strBuilder.toString(); + } + } + } + + return dString; + } + + /** + * Returns the byte[] representation of the given string using the given encoding. + * + * @param s + * source string + * @param encoding + * java encoding + * @return bytes + */ + public static byte[] getBytes(String s, String encoding) { + if (s == null) { + return new byte[0]; + } + if (encoding == null) { + return getBytes(s); + } + try { + return s.getBytes(encoding); + } catch (UnsupportedEncodingException uee) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("StringUtils.0", new Object[] { encoding }), uee); + } + + } + + /** + * Returns the byte[] representation of the given string properly wrapped between the given char delimiters using the given encoding. + * + * @param s + * source string + * @param beginWrap + * opening char delimiter + * @param endWrap + * closing char delimiter + * @param encoding + * java encoding + * @return bytes + */ + public static byte[] getBytesWrapped(String s, char beginWrap, char endWrap, String encoding) { + byte[] b; + + if (encoding == null) { + StringBuilder strBuilder = new StringBuilder(s.length() + 2); + strBuilder.append(beginWrap); + strBuilder.append(s); + strBuilder.append(endWrap); + + b = getBytes(strBuilder.toString()); + } else { + StringBuilder strBuilder = new StringBuilder(s.length() + 2); + strBuilder.append(beginWrap); + strBuilder.append(s); + strBuilder.append(endWrap); + + s = strBuilder.toString(); + b = getBytes(s, encoding); + } + + return b; + } + + /** + * Finds the position of a substring within a string ignoring case. + * + * @param searchIn + * the string to search in + * @param searchFor + * the array of strings to search for + * @return the position where searchFor is found within searchIn starting from startingPosition. + */ + public static int indexOfIgnoreCase(String searchIn, String searchFor) { + return indexOfIgnoreCase(0, searchIn, searchFor); + } + + /** + * Finds the position of a substring within a string ignoring case. + * + * @param startingPosition + * the position to start the search from + * @param searchIn + * the string to search in + * @param searchFor + * the array of strings to search for + * @return the position where searchFor is found within searchIn starting from startingPosition. + */ + public static int indexOfIgnoreCase(int startingPosition, String searchIn, String searchFor) { + if ((searchIn == null) || (searchFor == null)) { + return -1; + } + + int searchInLength = searchIn.length(); + int searchForLength = searchFor.length(); + int stopSearchingAt = searchInLength - searchForLength; + + if (startingPosition > stopSearchingAt || searchForLength == 0) { + return -1; + } + + // Some locales don't follow upper-case rule, so need to check both + char firstCharOfSearchForUc = Character.toUpperCase(searchFor.charAt(0)); + char firstCharOfSearchForLc = Character.toLowerCase(searchFor.charAt(0)); + + for (int i = startingPosition; i <= stopSearchingAt; i++) { + if (isCharAtPosNotEqualIgnoreCase(searchIn, i, firstCharOfSearchForUc, firstCharOfSearchForLc)) { + // find the first occurrence of the first character of searchFor in searchIn + while (++i <= stopSearchingAt && (isCharAtPosNotEqualIgnoreCase(searchIn, i, firstCharOfSearchForUc, firstCharOfSearchForLc))) { + } + } + + if (i <= stopSearchingAt && startsWithIgnoreCase(searchIn, i, searchFor)) { + return i; + } + } + + return -1; + } + + /** + * Finds the position of the first of a consecutive sequence of strings within a string, ignoring case, with the option to skip text delimited by given + * markers or within comments. + *

+ * Independently of the searchMode provided, when searching for the second and following strings SearchMode.SKIP_WHITE_SPACE will + * be added and SearchMode.SKIP_BETWEEN_MARKERS removed. + *

+ * + * @param startingPosition + * the position to start the search from + * @param searchIn + * the string to search in + * @param searchForSequence + * searchForSequence + * @param openingMarkers + * characters which delimit the beginning of a text block to skip + * @param closingMarkers + * characters which delimit the end of a text block to skip + * @param searchMode + * a Set, ideally an EnumSet, containing the flags from the enum StringUtils.SearchMode that determine the + * behavior of the search + * @return the position where searchFor is found within searchIn starting from startingPosition. + */ + public static int indexOfIgnoreCase(int startingPosition, String searchIn, String[] searchForSequence, String openingMarkers, String closingMarkers, + Set searchMode) { + if ((searchIn == null) || (searchForSequence == null)) { + return -1; + } + + int searchInLength = searchIn.length(); + int searchForLength = 0; + for (String searchForPart : searchForSequence) { + searchForLength += searchForPart.length(); + } // minimum length for searchFor (without gaps between words) + + if (searchForLength == 0) { + return -1; + } + + int searchForWordsCount = searchForSequence.length; + searchForLength += searchForWordsCount > 0 ? searchForWordsCount - 1 : 0; // add gaps between words + int stopSearchingAt = searchInLength - searchForLength; + + if (startingPosition > stopSearchingAt) { + return -1; + } + + if (searchMode.contains(SearchMode.SKIP_BETWEEN_MARKERS) + && (openingMarkers == null || closingMarkers == null || openingMarkers.length() != closingMarkers.length())) { + throw new IllegalArgumentException(Messages.getString("StringUtils.15", new String[] { openingMarkers, closingMarkers })); + } + + if (Character.isWhitespace(searchForSequence[0].charAt(0)) && searchMode.contains(SearchMode.SKIP_WHITE_SPACE)) { + // Can't skip white spaces if first searchFor char is one + searchMode = EnumSet.copyOf(searchMode); + searchMode.remove(SearchMode.SKIP_WHITE_SPACE); + } + + // searchMode set used to search 2nd and following words can't contain SearchMode.SKIP_BETWEEN_MARKERS and must + // contain SearchMode.SKIP_WHITE_SPACE + Set searchMode2 = EnumSet.of(SearchMode.SKIP_WHITE_SPACE); + searchMode2.addAll(searchMode); + searchMode2.remove(SearchMode.SKIP_BETWEEN_MARKERS); + + for (int positionOfFirstWord = startingPosition; positionOfFirstWord <= stopSearchingAt; positionOfFirstWord++) { + positionOfFirstWord = indexOfIgnoreCase(positionOfFirstWord, searchIn, searchForSequence[0], openingMarkers, closingMarkers, searchMode); + + if (positionOfFirstWord == -1 || positionOfFirstWord > stopSearchingAt) { + return -1; + } + + int startingPositionForNextWord = positionOfFirstWord + searchForSequence[0].length(); + int wc = 0; + boolean match = true; + while (++wc < searchForWordsCount && match) { + int positionOfNextWord = indexOfNextChar(startingPositionForNextWord, searchInLength - 1, searchIn, null, null, null, searchMode2); + if (startingPositionForNextWord == positionOfNextWord || !startsWithIgnoreCase(searchIn, positionOfNextWord, searchForSequence[wc])) { + // either no gap between words or match failed + match = false; + } else { + startingPositionForNextWord = positionOfNextWord + searchForSequence[wc].length(); + } + } + + if (match) { + return positionOfFirstWord; + } + } + + return -1; + } + + /** + * Finds the position of a substring within a string, ignoring case, with the option to skip text delimited by given markers or within comments. + * + * @param startingPosition + * the position to start the search from + * @param searchIn + * the string to search in + * @param searchFor + * the string to search for + * @param openingMarkers + * characters which delimit the beginning of a text block to skip + * @param closingMarkers + * characters which delimit the end of a text block to skip + * @param searchMode + * a Set, ideally an EnumSet, containing the flags from the enum StringUtils.SearchMode that determine the + * behavior of the search + * @return the position where searchFor is found within searchIn starting from startingPosition. + */ + public static int indexOfIgnoreCase(int startingPosition, String searchIn, String searchFor, String openingMarkers, String closingMarkers, + Set searchMode) { + return indexOfIgnoreCase(startingPosition, searchIn, searchFor, openingMarkers, closingMarkers, "", searchMode); + } + + /** + * Finds the position of a substring within a string, ignoring case, with the option to skip text delimited by given markers or within comments. + * + * @param startingPosition + * the position to start the search from + * @param searchIn + * the string to search in + * @param searchFor + * the string to search for + * @param openingMarkers + * characters which delimit the beginning of a text block to skip + * @param closingMarkers + * characters which delimit the end of a text block to skip + * @param overridingMarkers + * the subset of openingMarkers that override the remaining markers, e.g., if openingMarkers = "'(" and + * overridingMarkers = "'" then the block between the outer parenthesis in "start ('max('); end" is strictly consumed, + * otherwise the suffix " end" would end up being consumed too in the process of handling the nested parenthesis. + * @param searchMode + * a Set, ideally an EnumSet, containing the flags from the enum StringUtils.SearchMode that determine the + * behavior of the search + * @return the position where searchFor is found within searchIn starting from startingPosition. + */ + public static int indexOfIgnoreCase(int startingPosition, String searchIn, String searchFor, String openingMarkers, String closingMarkers, + String overridingMarkers, Set searchMode) { + if (searchIn == null || searchFor == null) { + return -1; + } + + int searchInLength = searchIn.length(); + int searchForLength = searchFor.length(); + int stopSearchingAt = searchInLength - searchForLength; + + if (startingPosition > stopSearchingAt || searchForLength == 0) { + return -1; + } + + if (searchMode.contains(SearchMode.SKIP_BETWEEN_MARKERS)) { + if (openingMarkers == null || closingMarkers == null || openingMarkers.length() != closingMarkers.length()) { + throw new IllegalArgumentException(Messages.getString("StringUtils.15", new String[] { openingMarkers, closingMarkers })); + } + if (overridingMarkers == null) { + throw new IllegalArgumentException(Messages.getString("StringUtils.16", new String[] { overridingMarkers, openingMarkers })); + } + for (char c : overridingMarkers.toCharArray()) { + if (openingMarkers.indexOf(c) == -1) { + throw new IllegalArgumentException(Messages.getString("StringUtils.16", new String[] { overridingMarkers, openingMarkers })); + } + } + } + + // Some locales don't follow upper-case rule, so need to check both + char firstCharOfSearchForUc = Character.toUpperCase(searchFor.charAt(0)); + char firstCharOfSearchForLc = Character.toLowerCase(searchFor.charAt(0)); + + if (Character.isWhitespace(firstCharOfSearchForLc) && searchMode.contains(SearchMode.SKIP_WHITE_SPACE)) { + // Can't skip white spaces if first searchFor char is one + searchMode = EnumSet.copyOf(searchMode); + searchMode.remove(SearchMode.SKIP_WHITE_SPACE); + } + + for (int i = startingPosition; i <= stopSearchingAt; i++) { + i = indexOfNextChar(i, stopSearchingAt, searchIn, openingMarkers, closingMarkers, overridingMarkers, searchMode); + + if (i == -1) { + return -1; + } + + char c = searchIn.charAt(i); + + if (isCharEqualIgnoreCase(c, firstCharOfSearchForUc, firstCharOfSearchForLc) && startsWithIgnoreCase(searchIn, i, searchFor)) { + return i; + } + } + + return -1; + } + + /** + * Finds the position the next character from a string, possibly skipping white space, comments and text between markers. + * + * @param startingPosition + * the position to start the search from + * @param stopPosition + * the position where to stop the search (inclusive) + * @param searchIn + * the string to search in + * @param openingMarkers + * characters which delimit the beginning of a text block to skip + * @param closingMarkers + * characters which delimit the end of a text block to skip + * @param overridingMarkers + * overridingMarkers + * @param searchMode + * a Set, ideally an EnumSet, containing the flags from the enum StringUtils.SearchMode that determine the + * behavior of the search + * @return the position where searchFor is found within searchIn starting from startingPosition. + */ + private static int indexOfNextChar(int startingPosition, int stopPosition, String searchIn, String openingMarkers, String closingMarkers, + String overridingMarkers, Set searchMode) { + if (searchIn == null) { + return -1; + } + + int searchInLength = searchIn.length(); + + if (startingPosition >= searchInLength) { + return -1; + } + + char c0 = Character.MIN_VALUE; // current char + char c1 = searchIn.charAt(startingPosition); // lookahead(1) + char c2 = startingPosition + 1 < searchInLength ? searchIn.charAt(startingPosition + 1) : Character.MIN_VALUE; // lookahead(2) + + for (int i = startingPosition; i <= stopPosition; i++) { + c0 = c1; + c1 = c2; + c2 = i + 2 < searchInLength ? searchIn.charAt(i + 2) : Character.MIN_VALUE; + + boolean dashDashCommentImmediateEnd = false; + int markerIndex = -1; + + if (searchMode.contains(SearchMode.ALLOW_BACKSLASH_ESCAPE) && c0 == '\\') { + i++; // next char is escaped, skip it + // reset lookahead + c1 = c2; + c2 = i + 2 < searchInLength ? searchIn.charAt(i + 2) : Character.MIN_VALUE; + + } else if (searchMode.contains(SearchMode.SKIP_BETWEEN_MARKERS) && (markerIndex = openingMarkers.indexOf(c0)) != -1) { + // marker found, skip until closing, while being aware of nested markers if opening and closing markers are distinct + int nestedMarkersCount = 0; + char openingMarker = c0; + char closingMarker = closingMarkers.charAt(markerIndex); + boolean outerIsAnOverridingMarker = overridingMarkers.indexOf(openingMarker) != -1; + while (++i <= stopPosition && ((c0 = searchIn.charAt(i)) != closingMarker || nestedMarkersCount != 0)) { + if (!outerIsAnOverridingMarker && overridingMarkers.indexOf(c0) != -1) { + // there is an overriding marker that needs to be consumed before returning to the previous marker + int overridingMarkerIndex = openingMarkers.indexOf(c0); // overridingMarkers must be a sub-list of openingMarkers + int overridingNestedMarkersCount = 0; + char overridingOpeningMarker = c0; + char overridingClosingMarker = closingMarkers.charAt(overridingMarkerIndex); + while (++i <= stopPosition && ((c0 = searchIn.charAt(i)) != overridingClosingMarker || overridingNestedMarkersCount != 0)) { + // do as before, but this marker can't be overridden + if (c0 == overridingOpeningMarker) { + overridingNestedMarkersCount++; + } else if (c0 == overridingClosingMarker) { + overridingNestedMarkersCount--; + } else if (searchMode.contains(SearchMode.ALLOW_BACKSLASH_ESCAPE) && c0 == '\\') { + i++; // next char is escaped, skip it + } + } + } else if (c0 == openingMarker) { + nestedMarkersCount++; + } else if (c0 == closingMarker) { + nestedMarkersCount--; + } else if (searchMode.contains(SearchMode.ALLOW_BACKSLASH_ESCAPE) && c0 == '\\') { + i++; // next char is escaped, skip it + } + } + // reset lookahead + c1 = i + 1 < searchInLength ? searchIn.charAt(i + 1) : Character.MIN_VALUE; + c2 = i + 2 < searchInLength ? searchIn.charAt(i + 2) : Character.MIN_VALUE; + + } else if (searchMode.contains(SearchMode.SKIP_BLOCK_COMMENTS) && c0 == '/' && c1 == '*') { + if (c2 != '!') { + // comments block found, skip until end of block ("*/") (backslash escape doesn't work on comments) + i++; // move to next char ('*') + while (++i <= stopPosition + && (searchIn.charAt(i) != '*' || (i + 1 < searchInLength ? searchIn.charAt(i + 1) : Character.MIN_VALUE) != '/')) { + // continue + } + i++; // move to next char ('/') + + } else { + // special non-comments block found, move to end of opening marker ("/*![12345]") + i++; // move to next char ('*') + i++; // move to next char ('!') + // check if a 5 digits MySQL version reference follows, if so skip them + int j = 1; + for (; j <= NON_COMMENTS_MYSQL_VERSION_REF_LENGTH; j++) { + if (i + j >= searchInLength || !Character.isDigit(searchIn.charAt(i + j))) { + break; + } + } + if (j == NON_COMMENTS_MYSQL_VERSION_REF_LENGTH) { + i += NON_COMMENTS_MYSQL_VERSION_REF_LENGTH; + } + } + // reset lookahead + c1 = i + 1 < searchInLength ? searchIn.charAt(i + 1) : Character.MIN_VALUE; + c2 = i + 2 < searchInLength ? searchIn.charAt(i + 2) : Character.MIN_VALUE; + + } else if (searchMode.contains(SearchMode.SKIP_BLOCK_COMMENTS) && c0 == '*' && c1 == '/') { + // special non-comments block closing marker ("*/") found - assume that if we get it here it's because it + // belongs to a non-comments block ("/*!"), otherwise the query should be misspelled as nesting comments isn't allowed. + i++; // move to next char ('/') + // reset lookahead + c1 = c2; + c2 = i + 2 < searchInLength ? searchIn.charAt(i + 2) : Character.MIN_VALUE; + + } else if (searchMode.contains(SearchMode.SKIP_LINE_COMMENTS) + && ((c0 == '-' && c1 == '-' && (Character.isWhitespace(c2) || (dashDashCommentImmediateEnd = c2 == ';') || c2 == Character.MIN_VALUE)) + || c0 == '#')) { + if (dashDashCommentImmediateEnd) { + // comments line found but closed immediately by query delimiter marker + i++; // move to next char ('-') + i++; // move to next char (';') + // reset lookahead + c1 = i + 1 < searchInLength ? searchIn.charAt(i + 1) : Character.MIN_VALUE; + c2 = i + 2 < searchInLength ? searchIn.charAt(i + 2) : Character.MIN_VALUE; + } else { + // comments line found, skip until eol (backslash escape doesn't work on comments) + while (++i <= stopPosition && (c0 = searchIn.charAt(i)) != '\n' && c0 != '\r') { + // continue + } + // reset lookahead + c1 = i + 1 < searchInLength ? searchIn.charAt(i + 1) : Character.MIN_VALUE; + if (c0 == '\r' && c1 == '\n') { + // \r\n sequence found + i++; // skip next char ('\n') + c1 = i + 1 < searchInLength ? searchIn.charAt(i + 1) : Character.MIN_VALUE; + } + c2 = i + 2 < searchInLength ? searchIn.charAt(i + 2) : Character.MIN_VALUE; + } + + } else if (!searchMode.contains(SearchMode.SKIP_WHITE_SPACE) || !Character.isWhitespace(c0)) { + return i; + } + } + + return -1; + } + + private static boolean isCharAtPosNotEqualIgnoreCase(String searchIn, int pos, char firstCharOfSearchForUc, char firstCharOfSearchForLc) { + return Character.toLowerCase(searchIn.charAt(pos)) != firstCharOfSearchForLc && Character.toUpperCase(searchIn.charAt(pos)) != firstCharOfSearchForUc; + } + + private static boolean isCharEqualIgnoreCase(char charToCompare, char compareToCharUC, char compareToCharLC) { + return Character.toLowerCase(charToCompare) == compareToCharLC || Character.toUpperCase(charToCompare) == compareToCharUC; + } + + /** + * Splits stringToSplit into a list, using the given delimiter + * + * @param stringToSplit + * the string to split + * @param delimiter + * the string to split on + * @param trim + * should the split strings be whitespace trimmed? + * + * @return the list of strings, split by delimiter + * + * @throws IllegalArgumentException + * if an error occurs + */ + public static List split(String stringToSplit, String delimiter, boolean trim) { + if (stringToSplit == null) { + return new ArrayList<>(); + } + + if (delimiter == null) { + throw new IllegalArgumentException(); + } + + String[] tokens = stringToSplit.split(delimiter, -1); + List tokensList = Arrays.asList(tokens); + if (trim) { + tokensList = tokensList.stream().map(String::trim).collect(Collectors.toList()); + } + return tokensList; + } + + /** + * Splits stringToSplit into a list, using the given delimiter and skipping all between the given markers. + * + * @param stringToSplit + * the string to split + * @param delimiter + * the string to split on + * @param openingMarkers + * characters which delimit the beginning of a text block to skip + * @param closingMarkers + * characters which delimit the end of a text block to skip + * @param trim + * should the split strings be whitespace trimmed? + * + * @return the list of strings, split by delimiter + * + * @throws IllegalArgumentException + * if an error occurs + */ + public static List split(String stringToSplit, String delimiter, String openingMarkers, String closingMarkers, boolean trim) { + return split(stringToSplit, delimiter, openingMarkers, closingMarkers, "", trim); + } + + /** + * Splits stringToSplit into a list, using the given delimiter and skipping all between the given markers. + * + * @param stringToSplit + * the string to split + * @param delimiter + * the string to split on + * @param openingMarkers + * characters which delimit the beginning of a text block to skip + * @param closingMarkers + * characters which delimit the end of a text block to skip + * @param trim + * should the split strings be whitespace trimmed? + * @param searchMode + * a Set, ideally an EnumSet, containing the flags from the enum StringUtils.SearchMode that determine the + * behaviour of the search + * + * @return the list of strings, split by delimiter + * + * @throws IllegalArgumentException + * if an error occurs + */ + public static List split(String stringToSplit, String delimiter, String openingMarkers, String closingMarkers, boolean trim, + Set searchMode) { + return split(stringToSplit, delimiter, openingMarkers, closingMarkers, "", trim, searchMode); + } + + /** + * Splits stringToSplit into a list, using the given delimiter and skipping all between the given markers. + * + * @param stringToSplit + * the string to split + * @param delimiter + * the string to split on + * @param openingMarkers + * characters which delimit the beginning of a text block to skip + * @param closingMarkers + * characters which delimit the end of a text block to skip + * @param overridingMarkers + * the subset of openingMarkers that override the remaining markers, e.g., if openingMarkers = "'(" and + * overridingMarkers = "'" then the block between the outer parenthesis in "start ('max('); end" is strictly consumed, + * otherwise the suffix " end" would end up being consumed too in the process of handling the nested parenthesis. + * @param trim + * should the split strings be whitespace trimmed? + * + * @return the list of strings, split by delimiter + * + * @throws IllegalArgumentException + * if an error occurs + */ + public static List split(String stringToSplit, String delimiter, String openingMarkers, String closingMarkers, String overridingMarkers, + boolean trim) { + return split(stringToSplit, delimiter, openingMarkers, closingMarkers, overridingMarkers, trim, SEARCH_MODE__MRK_COM_WS); + } + + /** + * Splits stringToSplit into a list, using the given delimiter and skipping all between the given markers. + * + * @param stringToSplit + * the string to split + * @param delimiter + * the string to split on + * @param openingMarkers + * characters which delimit the beginning of a text block to skip + * @param closingMarkers + * characters which delimit the end of a text block to skip + * @param overridingMarkers + * the subset of openingMarkers that override the remaining markers, e.g., if openingMarkers = "'(" and + * overridingMarkers = "'" then the block between the outer parenthesis in "start ('max('); end" is strictly consumed, + * otherwise the suffix " end" would end up being consumed too in the process of handling the nested parenthesis. + * @param trim + * should the split strings be whitespace trimmed? + * @param searchMode + * a Set, ideally an EnumSet, containing the flags from the enum StringUtils.SearchMode that determine the + * behaviour of the search + * + * @return the list of strings, split by delimiter + * + * @throws IllegalArgumentException + * if an error occurs + */ + public static List split(String stringToSplit, String delimiter, String openingMarkers, String closingMarkers, String overridingMarkers, + boolean trim, Set searchMode) { + if (stringToSplit == null) { + return new ArrayList<>(); + } + + if (delimiter == null) { + throw new IllegalArgumentException(); + } + + int delimPos = 0; + int currentPos = 0; + + List splitTokens = new ArrayList<>(); + + while ((delimPos = indexOfIgnoreCase(currentPos, stringToSplit, delimiter, openingMarkers, closingMarkers, overridingMarkers, searchMode)) != -1) { + String token = stringToSplit.substring(currentPos, delimPos); + if (trim) { + token = token.trim(); + } + splitTokens.add(token); + currentPos = delimPos + delimiter.length(); + } + + String token = stringToSplit.substring(currentPos); + if (trim) { + token = token.trim(); + } + splitTokens.add(token); + + return splitTokens; + } + + private static boolean startsWith(byte[] dataFrom, String chars) { + int charsLength = chars.length(); + + if (dataFrom.length < charsLength) { + return false; + } + for (int i = 0; i < charsLength; i++) { + if (dataFrom[i] != chars.charAt(i)) { + return false; + } + } + return true; + } + + /** + * Determines whether or not the string 'searchIn' contains the string 'searchFor', dis-regarding case starting at 'startAt' Shorthand for a + * String.regionMatch(...) + * + * @param searchIn + * the string to search in + * @param startAt + * the position to start at + * @param searchFor + * the string to search for + * + * @return whether searchIn starts with searchFor, ignoring case + */ + public static boolean startsWithIgnoreCase(String searchIn, int startAt, String searchFor) { + return searchIn.regionMatches(true, startAt, searchFor, 0, searchFor.length()); + } + + /** + * Determines whether or not the string 'searchIn' starts with the string 'searchFor', dis-regarding case. Shorthand for a String.regionMatch(...) + * + * @param searchIn + * the string to search in + * @param searchFor + * the string to search for + * + * @return whether searchIn starts with searchFor, ignoring case + */ + public static boolean startsWithIgnoreCase(String searchIn, String searchFor) { + return startsWithIgnoreCase(searchIn, 0, searchFor); + } + + /** + * Determines whether or not the string 'searchIn' starts with the string 'searchFor', disregarding case,leading whitespace and non-alphanumeric characters. + * + * @param searchIn + * the string to search in + * @param searchFor + * the string to search for + * + * @return true if the string starts with 'searchFor' ignoring whitespace + */ + public static boolean startsWithIgnoreCaseAndNonAlphaNumeric(String searchIn, String searchFor) { + if (searchIn == null) { + return searchFor == null; + } + + int beginPos = 0; + int inLength = searchIn.length(); + + for (; beginPos < inLength; beginPos++) { + char c = searchIn.charAt(beginPos); + if (Character.isLetterOrDigit(c)) { + break; + } + } + + return startsWithIgnoreCase(searchIn, beginPos, searchFor); + } + + /** + * Determines whether or not the string 'searchIn' starts with the string 'searchFor', disregarding case and leading whitespace + * + * @param searchIn + * the string to search in + * @param searchFor + * the string to search for + * + * @return true if the string starts with 'searchFor' ignoring whitespace + */ + public static boolean startsWithIgnoreCaseAndWs(String searchIn, String searchFor) { + return startsWithIgnoreCaseAndWs(searchIn, searchFor, 0); + } + + /** + * Determines whether or not the string 'searchIn' contains the string 'searchFor', disregarding case and leading whitespace + * + * @param searchIn + * the string to search in + * @param searchFor + * the string to search for + * @param beginPos + * where to start searching + * + * @return true if the string starts with 'searchFor' ignoring whitespace + */ + + public static boolean startsWithIgnoreCaseAndWs(String searchIn, String searchFor, int beginPos) { + if (searchIn == null) { + return searchFor == null; + } + + int inLength = searchIn.length(); + + for (; beginPos < inLength; beginPos++) { + if (!Character.isWhitespace(searchIn.charAt(beginPos))) { + break; + } + } + + return startsWithIgnoreCase(searchIn, beginPos, searchFor); + } + + /** + * Determines whether or not the string 'searchIn' starts with one of the strings in 'searchFor', disregarding case and leading whitespace + * + * @param searchIn + * the string to search in + * @param searchFor + * the string array to search for + * + * @return the 'searchFor' array index that matched or -1 if none matches + */ + public static int startsWithIgnoreCaseAndWs(String searchIn, String[] searchFor) { + for (int i = 0; i < searchFor.length; i++) { + if (startsWithIgnoreCaseAndWs(searchIn, searchFor[i], 0)) { + return i; + } + } + return -1; + } + + /** + * Determines whether or not the string 'searchIn' ends with the string 'searchFor', dis-regarding case starting at 'startAt' Shorthand for a + * String.regionMatch(...) + * + * @param searchIn + * the string to search in + * @param searchFor + * the string to search for + * + * @return whether searchIn ends with searchFor, ignoring case + */ + public static boolean endsWithIgnoreCase(String searchIn, String searchFor) { + int len = searchFor.length(); + return searchIn.regionMatches(true, searchIn.length() - len, searchFor, 0, len); + } + + /** + * @param source + * bytes to strip + * @param prefix + * prefix + * @param suffix + * suffix + * @return result bytes + */ + public static byte[] stripEnclosure(byte[] source, String prefix, String suffix) { + if (source.length >= prefix.length() + suffix.length() && startsWith(source, prefix) && endsWith(source, suffix)) { + + int totalToStrip = prefix.length() + suffix.length(); + int enclosedLength = source.length - totalToStrip; + byte[] enclosed = new byte[enclosedLength]; + + int startPos = prefix.length(); + int numToCopy = enclosed.length; + System.arraycopy(source, startPos, enclosed, 0, numToCopy); + + return enclosed; + } + return source; + } + + /** + * Returns the bytes as an ASCII String. + * + * @param buffer + * the bytes representing the string + * + * @return The ASCII String. + */ + public static String toAsciiString(byte[] buffer) { + return toAsciiString(buffer, 0, buffer.length); + } + + /** + * Returns the bytes as an ASCII String. + * + * @param buffer + * the bytes to convert + * @param startPos + * the position to start converting + * @param length + * the length of the string to convert + * + * @return the ASCII string + */ + public static String toAsciiString(byte[] buffer, int startPos, int length) { + char[] charArray = new char[length]; + int readpoint = startPos; + + for (int i = 0; i < length; i++) { + charArray[i] = (char) buffer[readpoint]; + readpoint++; + } + + return new String(charArray); + } + + /** + * Compares searchIn against searchForWildcard with wildcards, in a case insensitive manner. + * + * @param searchIn + * the string to search in + * @param searchFor + * the string to search for, using the 'standard' SQL wildcard chars of '%' and '_' + * @return true if matches + */ + public static boolean wildCompareIgnoreCase(String searchIn, String searchFor) { + return wildCompareInternal(searchIn, searchFor) == WILD_COMPARE_MATCH; + } + + /** + * Compares searchIn against searchForWildcard with wildcards (heavily borrowed from strings/ctype-simple.c in the server sources) + * + * This method does a single passage matching for normal characters and WILDCARD_ONE (_), and recursive matching for WILDCARD_MANY (%) which may be repeated + * for as many anchor chars are found. + * + * @param searchIn + * the string to search in + * @param searchFor + * the string to search for, using the 'standard' SQL wildcard chars of '%' and '_' + * + * @return WILD_COMPARE_MATCH if matched, WILD_COMPARE_NO_MATCH if not matched, WILD_COMPARE_CONTINUE_WITH_WILD if not matched yet, but it may in one of + * following recursion rounds + */ + private static int wildCompareInternal(String searchIn, String searchFor) { + if ((searchIn == null) || (searchFor == null)) { + return WILD_COMPARE_NO_MATCH; + } + + if (searchFor.equals("%")) { + return WILD_COMPARE_MATCH; + } + + int searchForPos = 0; + int searchForEnd = searchFor.length(); + + int searchInPos = 0; + int searchInEnd = searchIn.length(); + + int result = WILD_COMPARE_NO_MATCH; /* Not found, using wildcards */ + + while (searchForPos != searchForEnd) { + while ((searchFor.charAt(searchForPos) != WILDCARD_MANY) && (searchFor.charAt(searchForPos) != WILDCARD_ONE)) { + if ((searchFor.charAt(searchForPos) == WILDCARD_ESCAPE) && ((searchForPos + 1) != searchForEnd)) { + searchForPos++; + } + + if ((searchInPos == searchInEnd) + || (Character.toUpperCase(searchFor.charAt(searchForPos++)) != Character.toUpperCase(searchIn.charAt(searchInPos++)))) { + return WILD_COMPARE_CONTINUE_WITH_WILD; /* No match */ + } + + if (searchForPos == searchForEnd) { + return ((searchInPos != searchInEnd) ? WILD_COMPARE_CONTINUE_WITH_WILD : WILD_COMPARE_MATCH); /* Match if both are at end */ + } + + result = WILD_COMPARE_CONTINUE_WITH_WILD; /* Found an anchor char */ + } + + if (searchFor.charAt(searchForPos) == WILDCARD_ONE) { + do { + if (searchInPos == searchInEnd) { /* Skip one char if possible */ + return result; + } + searchInPos++; + } while ((++searchForPos < searchForEnd) && (searchFor.charAt(searchForPos) == WILDCARD_ONE)); + + if (searchForPos == searchForEnd) { + break; + } + } + + if (searchFor.charAt(searchForPos) == WILDCARD_MANY) { /* Found w_many */ + searchForPos++; + + /* Remove any '%' and '_' from the wild search string */ + for (; searchForPos != searchForEnd; searchForPos++) { + if (searchFor.charAt(searchForPos) == WILDCARD_MANY) { + continue; + } + + if (searchFor.charAt(searchForPos) == WILDCARD_ONE) { + if (searchInPos == searchInEnd) { /* Skip one char if possible */ + return WILD_COMPARE_NO_MATCH; + } + searchInPos++; + continue; + } + + break; /* Not a wild character */ + } + + if (searchForPos == searchForEnd) { + return WILD_COMPARE_MATCH; /* Ok if w_many is last */ + } + + if (searchInPos == searchInEnd) { + return WILD_COMPARE_NO_MATCH; + } + + char cmp; + if (((cmp = searchFor.charAt(searchForPos)) == WILDCARD_ESCAPE) && ((searchForPos + 1) != searchForEnd)) { + cmp = searchFor.charAt(++searchForPos); + } + + searchForPos++; + + do { + while ((searchInPos != searchInEnd) && (Character.toUpperCase(searchIn.charAt(searchInPos)) != Character.toUpperCase(cmp))) { + searchInPos++; + } /* Searches for an anchor char */ + + if (searchInPos++ == searchInEnd) { + return WILD_COMPARE_NO_MATCH; + } + + int tmp = wildCompareInternal(searchIn.substring(searchInPos), searchFor.substring(searchForPos)); + if (tmp <= 0) { + return tmp; + } + + } while (searchInPos != searchInEnd); + + return WILD_COMPARE_NO_MATCH; + } + } + + return ((searchInPos != searchInEnd) ? WILD_COMPARE_CONTINUE_WITH_WILD : WILD_COMPARE_MATCH); + } + + public static int lastIndexOf(byte[] s, char c) { + if (s == null) { + return -1; + } + + for (int i = s.length - 1; i >= 0; i--) { + if (s[i] == c) { + return i; + } + } + + return -1; + } + + public static int indexOf(byte[] s, char c) { + if (s == null) { + return -1; + } + + int length = s.length; + + for (int i = 0; i < length; i++) { + if (s[i] == c) { + return i; + } + } + + return -1; + } + + public static boolean isNullOrEmpty(String toTest) { + return (toTest == null || toTest.isEmpty()); + } + + /** + * Two given strings are considered equal if both are null or if they have the same string value. + * + * @param str1 + * first string to compare + * @param str2 + * fecond string to compare + * @return + * true if both strings are null or have the same value + */ + public static boolean nullSafeEqual(String str1, String str2) { + return str1 == null && str2 == null || str1 != null && str1.equals(str2); + } + + /** + * Returns the given string, with comments removed + * + * @param src + * the source string + * @param stringOpens + * characters which delimit the "open" of a string + * @param stringCloses + * characters which delimit the "close" of a string, in + * counterpart order to stringOpens + * @param slashStarComments + * strip slash-star type "C" style comments + * @param slashSlashComments + * strip slash-slash C++ style comments to end-of-line + * @param hashComments + * strip #-style comments to end-of-line + * @param dashDashComments + * strip "--" style comments to end-of-line + * @return the input string with all comment-delimited data removed + */ + public static String stripComments(String src, String stringOpens, String stringCloses, boolean slashStarComments, boolean slashSlashComments, + boolean hashComments, boolean dashDashComments) { + if (src == null) { + return null; + } + + StringBuilder strBuilder = new StringBuilder(src.length()); + + // It's just more natural to deal with this as a stream when parsing..This code is currently only called when parsing the kind of metadata that + // developers are strongly recommended to cache anyways, so we're not worried about the _1_ extra object allocation if it cleans up the code + + StringReader sourceReader = new StringReader(src); + + int contextMarker = Character.MIN_VALUE; + boolean escaped = false; + int markerTypeFound = -1; + + int ind = 0; + + int currentChar = 0; + + try { + while ((currentChar = sourceReader.read()) != -1) { + + if (markerTypeFound != -1 && currentChar == stringCloses.charAt(markerTypeFound) && !escaped) { + contextMarker = Character.MIN_VALUE; + markerTypeFound = -1; + } else if ((ind = stringOpens.indexOf(currentChar)) != -1 && !escaped && contextMarker == Character.MIN_VALUE) { + markerTypeFound = ind; + contextMarker = currentChar; + } + + if (contextMarker == Character.MIN_VALUE && currentChar == '/' && (slashSlashComments || slashStarComments)) { + currentChar = sourceReader.read(); + if (currentChar == '*' && slashStarComments) { + int prevChar = 0; + while ((currentChar = sourceReader.read()) != '/' || prevChar != '*') { + if (currentChar == '\r') { + + currentChar = sourceReader.read(); + if (currentChar == '\n') { + currentChar = sourceReader.read(); + } + } else { + if (currentChar == '\n') { + + currentChar = sourceReader.read(); + } + } + if (currentChar < 0) { + break; + } + prevChar = currentChar; + } + continue; + } else if (currentChar == '/' && slashSlashComments) { + while ((currentChar = sourceReader.read()) != '\n' && currentChar != '\r' && currentChar >= 0) { + } + } + } else if (contextMarker == Character.MIN_VALUE && currentChar == '#' && hashComments) { + // Slurp up everything until the newline + while ((currentChar = sourceReader.read()) != '\n' && currentChar != '\r' && currentChar >= 0) { + } + } else if (contextMarker == Character.MIN_VALUE && currentChar == '-' && dashDashComments) { + currentChar = sourceReader.read(); + + if (currentChar == -1 || currentChar != '-') { + strBuilder.append('-'); + + if (currentChar != -1) { + strBuilder.append((char) currentChar); + } + + continue; + } + + // Slurp up everything until the newline + + while ((currentChar = sourceReader.read()) != '\n' && currentChar != '\r' && currentChar >= 0) { + } + } + + if (currentChar != -1) { + strBuilder.append((char) currentChar); + } + } + } catch (IOException ioEx) { + // we'll never see this from a StringReader + } + + return strBuilder.toString(); + } + + /** + * Next two functions are to help DBMD check if + * the given string is in form of database.name and return it + * as "database";"name" with comments removed. + * If string is NULL or wildcard (%), returns null and exits. + * + * First, we sanitize... + * + * @param src + * the source string + * @return the input string with all comment-delimited data removed + */ + public static String sanitizeProcOrFuncName(String src) { + if ((src == null) || (src.equals("%"))) { + return null; + } + + return src; + } + + /** + * Splits an entity identifier into its parts (database and entity name) and returns a list containing the two elements. If the identifier doesn't contain + * the database part then the argument db is used in its place and source corresponds to the full entity name. + * If argument source is NULL or wildcard (%), returns an empty list. + * + * @param source + * the source string + * @param db + * database, if available + * @param quoteId + * quote character as defined on server + * @param isNoBslashEscSet + * is our connection in no BackSlashEscape mode + * @return the input string with all comment-delimited data removed + */ + public static List splitDBdotName(String source, String db, String quoteId, boolean isNoBslashEscSet) { + if ((source == null) || (source.equals("%"))) { + return Collections.emptyList(); + } + + int dotIndex = -1; + if (" ".equals(quoteId)) { + dotIndex = source.indexOf("."); + } else { + dotIndex = indexOfIgnoreCase(0, source, ".", quoteId, quoteId, isNoBslashEscSet ? SEARCH_MODE__MRK_WS : SEARCH_MODE__BSESC_MRK_WS); + } + + String database = db; + String entityName; + if (dotIndex != -1) { + database = unQuoteIdentifier(source.substring(0, dotIndex), quoteId); + entityName = unQuoteIdentifier(source.substring(dotIndex + 1), quoteId); + } else { + entityName = unQuoteIdentifier(source, quoteId); + } + + return Arrays.asList(database, entityName); + } + + /** + * Builds and returns a fully qualified name, quoted if necessary, for the given database entity. + * + * @param db + * database name + * @param entity + * identifier + * @param quoteId + * quote character as defined on server + * @param isPedantic + * are we in pedantic mode + * @return fully qualified name + */ + public static String getFullyQualifiedName(String db, String entity, String quoteId, boolean isPedantic) { + StringBuilder fullyQualifiedName = new StringBuilder(StringUtils.quoteIdentifier(db == null ? "" : db, quoteId, isPedantic)); + fullyQualifiedName.append('.'); + fullyQualifiedName.append(StringUtils.quoteIdentifier(entity, quoteId, isPedantic)); + return fullyQualifiedName.toString(); + } + + public static boolean isEmptyOrWhitespaceOnly(String str) { + if (str == null || str.length() == 0) { + return true; + } + + int length = str.length(); + + for (int i = 0; i < length; i++) { + if (!Character.isWhitespace(str.charAt(i))) { + return false; + } + } + + return true; + } + + public static String escapeQuote(String src, String quotChar) { + if (src == null) { + return null; + } + + src = StringUtils.toString(stripEnclosure(src.getBytes(), quotChar, quotChar)); + + int lastNdx = src.indexOf(quotChar); + String tmpSrc; + String tmpRest; + + tmpSrc = src.substring(0, lastNdx); + tmpSrc = tmpSrc + quotChar + quotChar; + + tmpRest = src.substring(lastNdx + 1, src.length()); + + lastNdx = tmpRest.indexOf(quotChar); + while (lastNdx > -1) { + + tmpSrc = tmpSrc + tmpRest.substring(0, lastNdx); + tmpSrc = tmpSrc + quotChar + quotChar; + tmpRest = tmpRest.substring(lastNdx + 1, tmpRest.length()); + + lastNdx = tmpRest.indexOf(quotChar); + } + + tmpSrc = tmpSrc + tmpRest; + src = tmpSrc; + + return src; + } + + /** + * Surrounds identifier with quoteChar and duplicates these symbols inside the identifier. + * + * @param quoteChar + * ` or " + * @param identifier + * in pedantic mode (connection property pedantic=true) identifier is treated as unquoted + * (as it is stored in the database) even if it starts and ends with quoteChar; + * in non-pedantic mode if identifier starts and ends with quoteChar method treats it as already quoted and doesn't modify. + * @param isPedantic + * are we in pedantic mode + * + * @return + * With quoteChar="`":
+ *
    + *
  • null {@code ->} null
    • + *
  • abc {@code ->} `abc`
    • + *
  • ab`c {@code ->} `ab``c`
    • + *
  • ab"c {@code ->} `ab"c`
    • + *
  • `ab``c` {@code ->} `ab``c` in non-pedantic mode or ```ab````c``` in pedantic mode
    • + *
+ * With quoteChar="\"":
+ *
    + *
  • null {@code ->} null
    • + *
  • abc {@code ->} "abc"
    • + *
  • ab`c {@code ->} "ab`c"
    • + *
  • ab"c {@code ->} "ab""c"
    • + *
  • "ab""c" {@code ->} "ab""c" in non-pedantic mode or """ab""""c""" in pedantic mode
    • + *
+ */ + public static String quoteIdentifier(String identifier, String quoteChar, boolean isPedantic) { + if (identifier == null) { + return null; + } + + identifier = identifier.trim(); + + int quoteCharLength = quoteChar.length(); + if (quoteCharLength == 0) { + return identifier; + } + + // Check if the identifier is correctly quoted and if quotes within are correctly escaped. If not, quote and escape it. + if (!isPedantic && identifier.startsWith(quoteChar) && identifier.endsWith(quoteChar)) { + // Trim outermost quotes from the identifier. + String identifierQuoteTrimmed = identifier.substring(quoteCharLength, identifier.length() - quoteCharLength); + + // Check for pairs of quotes. + int quoteCharPos = identifierQuoteTrimmed.indexOf(quoteChar); + while (quoteCharPos >= 0) { + int quoteCharNextExpectedPos = quoteCharPos + quoteCharLength; + int quoteCharNextPosition = identifierQuoteTrimmed.indexOf(quoteChar, quoteCharNextExpectedPos); + + if (quoteCharNextPosition == quoteCharNextExpectedPos) { + quoteCharPos = identifierQuoteTrimmed.indexOf(quoteChar, quoteCharNextPosition + quoteCharLength); + } else { + // Not a pair of quotes! + break; + } + } + + if (quoteCharPos < 0) { + return identifier; + } + } + + return quoteChar + identifier.replaceAll(quoteChar, quoteChar + quoteChar) + quoteChar; + } + + /** + * Surrounds identifier with "`" and duplicates these symbols inside the identifier. + * + * @param identifier + * in pedantic mode (connection property pedantic=true) identifier is treated as unquoted + * (as it is stored in the database) even if it starts and ends with "`"; + * in non-pedantic mode if identifier starts and ends with "`" method treats it as already quoted and doesn't modify. + * @param isPedantic + * are we in pedantic mode + * + * @return + *
    + *
  • null {@code ->} null
    • + *
  • abc {@code ->} `abc`
    • + *
  • ab`c {@code ->} `ab``c`
    • + *
  • ab"c {@code ->} `ab"c`
    • + *
  • `ab``c` {@code ->} `ab``c` in non-pedantic mode or ```ab````c``` in pedantic mode
    • + *
+ */ + public static String quoteIdentifier(String identifier, boolean isPedantic) { + return quoteIdentifier(identifier, "`", isPedantic); + } + + /** + * Trims identifier, removes quote chars from first and last positions + * and replaces double occurrences of quote char from entire identifier, + * i.e converts quoted identifier into form as it is stored in database. + * + * @param identifier + * identifier + * @param quoteChar + * ` or " + * @return + *
    + *
  • null {@code ->} null
    • + *
  • abc {@code ->} abc
    • + *
  • `abc` {@code ->} abc
    • + *
  • `ab``c` {@code ->} ab`c
    • + *
  • `"ab`c"` {@code ->} "ab`c"
    • + *
  • `ab"c` {@code ->} ab"c
    • + *
  • "abc" {@code ->} abc
    • + *
  • "`ab""c`" {@code ->} `ab"c`
    • + *
  • "ab`c" {@code ->} ab`c
    • + *
+ */ + public static String unQuoteIdentifier(String identifier, String quoteChar) { + if (identifier == null) { + return null; + } + + identifier = identifier.trim(); + + int quoteCharLength = quoteChar.length(); + if (quoteCharLength == 0) { + return identifier; + } + + // Check if the identifier is really quoted or if it simply contains quote chars in it (assuming that the value is a valid identifier). + if (identifier.startsWith(quoteChar) && identifier.endsWith(quoteChar)) { + // Trim outermost quotes from the identifier. + String identifierQuoteTrimmed = identifier.substring(quoteCharLength, identifier.length() - quoteCharLength); + + // Check for pairs of quotes. + int quoteCharPos = identifierQuoteTrimmed.indexOf(quoteChar); + while (quoteCharPos >= 0) { + int quoteCharNextExpectedPos = quoteCharPos + quoteCharLength; + int quoteCharNextPosition = identifierQuoteTrimmed.indexOf(quoteChar, quoteCharNextExpectedPos); + + if (quoteCharNextPosition == quoteCharNextExpectedPos) { + quoteCharPos = identifierQuoteTrimmed.indexOf(quoteChar, quoteCharNextPosition + quoteCharLength); + } else { + // Not a pair of quotes! Return as it is... + return identifier; + } + } + + return identifier.substring(quoteCharLength, (identifier.length() - quoteCharLength)).replaceAll(quoteChar + quoteChar, quoteChar); + } + + return identifier; + } + + public static int indexOfQuoteDoubleAware(String searchIn, String quoteChar, int startFrom) { + if (searchIn == null || quoteChar == null || quoteChar.length() == 0 || startFrom > searchIn.length()) { + return -1; + } + + int lastIndex = searchIn.length() - 1; + + int beginPos = startFrom; + int pos = -1; + + boolean next = true; + while (next) { + pos = searchIn.indexOf(quoteChar, beginPos); + if (pos == -1 || pos == lastIndex || !searchIn.startsWith(quoteChar, pos + 1)) { + next = false; + } else { + beginPos = pos + 2; + } + } + + return pos; + } + + public static String toString(byte[] value, int offset, int length, String encoding) { + if (encoding == null || "null".equalsIgnoreCase(encoding)) { + return new String(value, offset, length); + } + try { + return new String(value, offset, length, encoding); + } catch (UnsupportedEncodingException uee) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("StringUtils.0", new Object[] { encoding }), uee); + } + } + + public static String toString(byte[] value, String encoding) { + if (encoding == null) { + return new String(value); + } + try { + return new String(value, encoding); + } catch (UnsupportedEncodingException uee) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("StringUtils.0", new Object[] { encoding }), uee); + } + } + + public static String toString(byte[] value, int offset, int length) { + return new String(value, offset, length); + } + + public static String toString(byte[] value) { + return new String(value); + } + + /** + * Returns the byte[] representation of subset of the given char[] using the default/platform encoding. + * + * @param value + * chars + * @return bytes + */ + public static byte[] getBytes(char[] value) { + return getBytes(value, 0, value.length); + } + + /** + * Returns the byte[] representation of subset of the given char[] using the given encoding. + * + * @param c + * chars + * @param encoding + * java encoding + * @return bytes + */ + public static byte[] getBytes(char[] c, String encoding) { + return getBytes(c, 0, c.length, encoding); + } + + public static byte[] getBytes(char[] value, int offset, int length) { + return getBytes(value, offset, length, null); + } + + /** + * Returns the byte[] representation of subset of the given char[] using the given encoding. + * + * @param value + * chars + * @param offset + * offset + * @param length + * length + * @param encoding + * java encoding + * @return bytes + */ + public static byte[] getBytes(char[] value, int offset, int length, String encoding) { + Charset cs; + try { + if (encoding == null) { + cs = Charset.defaultCharset(); + } else { + cs = Charset.forName(encoding); + } + } catch (UnsupportedCharsetException ex) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("StringUtils.0", new Object[] { encoding }), ex); + } + ByteBuffer buf = cs.encode(CharBuffer.wrap(value, offset, length)); + + // can't simply .array() this to get the bytes especially with variable-length charsets the buffer is sometimes larger than the actual encoded data + int encodedLen = buf.limit(); + byte[] asBytes = new byte[encodedLen]; + buf.get(asBytes, 0, encodedLen); + + return asBytes; + } + + public static byte[] getBytes(String value) { + return value.getBytes(); + } + + public static byte[] getBytes(String value, int offset, int length) { + return value.substring(offset, offset + length).getBytes(); + } + + public static byte[] getBytes(String value, int offset, int length, String encoding) { + if (encoding == null) { + return getBytes(value, offset, length); + } + + try { + return value.substring(offset, offset + length).getBytes(encoding); + } catch (UnsupportedEncodingException uee) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("StringUtils.0", new Object[] { encoding }), uee); + } + } + + public static final boolean isValidIdChar(char c) { + return VALID_ID_CHARS.indexOf(c) != -1; + } + + private static final char[] HEX_DIGITS = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; + + public static void appendAsHex(StringBuilder builder, byte[] bytes) { + builder.append("0x"); + for (byte b : bytes) { + builder.append(HEX_DIGITS[(b >>> 4) & 0xF]).append(HEX_DIGITS[b & 0xF]); + } + } + + public static void appendAsHex(StringBuilder builder, int value) { + if (value == 0) { + builder.append("0x0"); + return; + } + + int shift = 32; + byte nibble; + boolean nonZeroFound = false; + + builder.append("0x"); + do { + shift -= 4; + nibble = (byte) ((value >>> shift) & 0xF); + if (nonZeroFound) { + builder.append(HEX_DIGITS[nibble]); + } else if (nibble != 0) { + builder.append(HEX_DIGITS[nibble]); + nonZeroFound = true; + } + } while (shift != 0); + } + + public static byte[] getBytesNullTerminated(String value, String encoding) { + Charset cs = Charset.forName(encoding); + ByteBuffer buf = cs.encode(value); + int encodedLen = buf.limit(); + byte[] asBytes = new byte[encodedLen + 1]; + buf.get(asBytes, 0, encodedLen); + asBytes[encodedLen] = 0; + + return asBytes; + } + + public static boolean canHandleAsServerPreparedStatementNoCache(String sql, ServerVersion serverVersion, boolean allowMultiQueries, + boolean noBackslashEscapes, boolean useAnsiQuotes) { + + // Can't use server-side prepare for CALL + if (startsWithIgnoreCaseAndNonAlphaNumeric(sql, "CALL")) { + return false; + } + + boolean canHandleAsStatement = true; + + boolean allowBackslashEscapes = !noBackslashEscapes; + String quoteChar = useAnsiQuotes ? "\"" : "'"; + + if (allowMultiQueries) { + if (StringUtils.indexOfIgnoreCase(0, sql, ";", quoteChar, quoteChar, + allowBackslashEscapes ? StringUtils.SEARCH_MODE__ALL : StringUtils.SEARCH_MODE__MRK_COM_WS) != -1) { + canHandleAsStatement = false; + } + } else if (startsWithIgnoreCaseAndWs(sql, "XA ")) { + canHandleAsStatement = false; + } else if (startsWithIgnoreCaseAndWs(sql, "CREATE TABLE")) { + canHandleAsStatement = false; + } else if (startsWithIgnoreCaseAndWs(sql, "DO")) { + canHandleAsStatement = false; + } else if (startsWithIgnoreCaseAndWs(sql, "SET")) { + canHandleAsStatement = false; + } else if (StringUtils.startsWithIgnoreCaseAndWs(sql, "SHOW WARNINGS") && serverVersion.meetsMinimum(ServerVersion.parseVersion("5.7.2"))) { + canHandleAsStatement = false; + } else if (sql.startsWith("/* ping */")) { + canHandleAsStatement = false; + } + + return canHandleAsStatement; + } + + final static char[] EMPTY_SPACE = new char[255]; + + static { + for (int i = 0; i < EMPTY_SPACE.length; i++) { + EMPTY_SPACE[i] = ' '; + } + } + + public static String padString(String stringVal, int requiredLength) { + int currentLength = stringVal.length(); + int difference = requiredLength - currentLength; + + if (difference > 0) { + StringBuilder paddedBuf = new StringBuilder(requiredLength); + paddedBuf.append(stringVal); + paddedBuf.append(EMPTY_SPACE, 0, difference); + return paddedBuf.toString(); + } + + return stringVal; + } + + public static int safeIntParse(String intAsString) { + try { + return Integer.parseInt(intAsString); + } catch (NumberFormatException nfe) { + return 0; + } + } + + /** + * Checks is the CharSequence contains digits only. No leading sign and thousands or decimal separators are allowed. + * + * @param cs + * The CharSequence to check. + * @return + * {@code true} if the CharSequence not empty and contains only digits, {@code false} otherwise. + */ + public static boolean isStrictlyNumeric(CharSequence cs) { + if (cs == null || cs.length() == 0) { + return false; + } + for (int i = 0; i < cs.length(); i++) { + if (!Character.isDigit(cs.charAt(i))) { + return false; + } + } + return true; + } + + public static String safeTrim(String toTrim) { + return isNullOrEmpty(toTrim) ? toTrim : toTrim.trim(); + } + + /** + * Constructs a String containing all the elements in the String array bounded and joined by the provided concatenation elements. The last element uses a + * different delimiter. + * + * @param elems + * the String array from where to take the elements. + * @param prefix + * the prefix of the resulting String. + * @param midDelimiter + * the delimiter to be used between the N-1 elements + * @param lastDelimiter + * the delimiter to be used before the last element. + * @param suffix + * the suffix of the resulting String. + * @return + * a String built from the provided String array and concatenation elements. + */ + public static String stringArrayToString(String[] elems, String prefix, String midDelimiter, String lastDelimiter, String suffix) { + StringBuilder valuesString = new StringBuilder(); + if (elems.length > 1) { + valuesString.append(Arrays.stream(elems).limit(elems.length - 1).collect(Collectors.joining(midDelimiter, prefix, lastDelimiter))); + } else { + valuesString.append(prefix); + } + valuesString.append(elems[elems.length - 1]).append(suffix); + + return valuesString.toString(); + } + + /** + * Does the string contain wildcard symbols ('%' or '_'). Used in DatabaseMetaData. + * + * @param src + * string + * @return true if src contains wildcard symbols + */ + public static boolean hasWildcards(String src) { + return indexOfIgnoreCase(0, src, "%") > -1 || indexOfIgnoreCase(0, src, "_") > -1; + } + + public static String getUniqueSavepointId() { + String uuid = UUID.randomUUID().toString(); + return uuid.replaceAll("-", "_"); // for safety + } + + /** + * Joins all elements of the given list using serial comma (Oxford comma) rules. + * E.g.: + * - "A" + * - "A and B" + * - "A, B, and C" + * + * @param elements + * the elements to join + * @return + * the String with all elements, joined by commas and "and". + */ + public static String joinWithSerialComma(List elements) { + if (elements == null || elements.size() == 0) { + return ""; + } + if (elements.size() == 1) { + return elements.get(0).toString(); + } + if (elements.size() == 2) { + return elements.get(0) + " and " + elements.get(1); + } + return elements.subList(0, elements.size() - 1).stream().map(Object::toString).collect(Collectors.joining(", ", "", ", and ")) + + elements.get(elements.size() - 1).toString(); + } + + public static byte[] unquoteBytes(byte[] bytes) { + if ((bytes[0] == '\'') && (bytes[bytes.length - 1] == '\'')) { + + byte[] valNoQuotes = new byte[bytes.length - 2]; + int j = 0; + int quoteCnt = 0; + + for (int i = 1; i < bytes.length - 1; i++) { + if (bytes[i] == '\'') { + quoteCnt++; + } else { + quoteCnt = 0; + } + + if (quoteCnt == 2) { + quoteCnt = 0; + } else { + valNoQuotes[j++] = bytes[i]; + } + } + + byte[] res = new byte[j]; + System.arraycopy(valNoQuotes, 0, res, 0, j); + + return res; + } + return bytes; + } + + public static byte[] quoteBytes(byte[] bytes) { + byte[] withQuotes = new byte[bytes.length * 2 + 2]; + int j = 0; + withQuotes[j++] = '\''; + for (int i = 0; i < bytes.length; i++) { + if (bytes[i] == '\'') { + withQuotes[j++] = '\''; + } + withQuotes[j++] = bytes[i]; + } + withQuotes[j++] = '\''; + + byte[] res = new byte[j]; + System.arraycopy(withQuotes, 0, res, 0, j); + return res; + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/TestUtils.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/TestUtils.java new file mode 100644 index 0000000..ae2017f --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/TestUtils.java @@ -0,0 +1,38 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.util; + +public class TestUtils { + + public static void dumpTestcaseQuery(String query) { + System.err.println(query); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/TimeUtil.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/TimeUtil.java new file mode 100644 index 0000000..af396d0 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/TimeUtil.java @@ -0,0 +1,513 @@ +/* + * Copyright (c) 2002, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.util; + +import java.io.IOException; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.sql.Time; +import java.sql.Timestamp; +import java.text.SimpleDateFormat; +import java.time.Duration; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.format.DateTimeFormatter; +import java.time.format.DateTimeFormatterBuilder; +import java.time.temporal.ChronoField; +import java.util.Calendar; +import java.util.Locale; +import java.util.Properties; +import java.util.TimeZone; +import java.util.regex.Pattern; + +import com.mysql.cj.Messages; +import com.mysql.cj.MysqlType; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.ExceptionInterceptor; +import com.mysql.cj.exceptions.InvalidConnectionAttributeException; +import com.mysql.cj.exceptions.WrongArgumentException; + +/** + * Time zone conversion routines and other time related methods + */ +public class TimeUtil { + static final TimeZone GMT_TIMEZONE = TimeZone.getTimeZone("GMT"); + + public static final DateTimeFormatter DATE_FORMATTER = DateTimeFormatter.ofPattern("yyyy-MM-dd"); + public static final DateTimeFormatter TIME_FORMATTER_NO_FRACT_NO_OFFSET = DateTimeFormatter.ofPattern("HH:mm:ss"); + public static final DateTimeFormatter TIME_FORMATTER_WITH_NANOS_NO_OFFSET = DateTimeFormatter.ofPattern("HH:mm:ss.SSSSSSSSS"); + public static final DateTimeFormatter TIME_FORMATTER_NO_FRACT_WITH_OFFSET = DateTimeFormatter.ofPattern("HH:mm:ssXXX"); + public static final DateTimeFormatter TIME_FORMATTER_WITH_NANOS_WITH_OFFSET = DateTimeFormatter.ofPattern("HH:mm:ss.SSSSSSSSSXXX"); + public static final DateTimeFormatter DATETIME_FORMATTER_NO_FRACT_NO_OFFSET = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); + public static final DateTimeFormatter DATETIME_FORMATTER_WITH_MILLIS_NO_OFFSET = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS"); + public static final DateTimeFormatter DATETIME_FORMATTER_WITH_NANOS_NO_OFFSET = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSSSSSSSS"); + public static final DateTimeFormatter DATETIME_FORMATTER_NO_FRACT_WITH_OFFSET = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ssXXX"); + public static final DateTimeFormatter DATETIME_FORMATTER_WITH_NANOS_WITH_OFFSET = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSSSSSSSSXXX"); + + public static final Pattern DATE_LITERAL_WITH_DELIMITERS = Pattern + .compile("(\\d{4}|\\d{2})[\\p{Punct}&&[^:]](([0])?[1-9]|[1][0-2])[\\p{Punct}&&[^:]](([0])?[1-9]|[1-2]\\d|[3][0-1])"); + public static final Pattern DATE_LITERAL_NO_DELIMITERS = Pattern.compile("(\\d{4}|\\d{2})([0][1-9]|[1][0-2])([0][1-9]|[1-2]\\d|[3][0-1])"); + + public static final Pattern TIME_LITERAL_WITH_DELIMITERS = Pattern.compile("(([0-1])?\\d|[2][0-3]):([0-5])?\\d(:([0-5])?\\d(\\.\\d{1,9})?)?"); + public static final Pattern TIME_LITERAL_SHORT6 = Pattern.compile("([0-1]\\d|[2][0-3])([0-5]\\d){2}(\\.\\d{1,9})?"); + public static final Pattern TIME_LITERAL_SHORT4 = Pattern.compile("([0-5]\\d){2}(\\.\\d{1,9})?"); + public static final Pattern TIME_LITERAL_SHORT2 = Pattern.compile("[0-5]\\d(\\.\\d{1,9})?"); + + public static final Pattern DATETIME_LITERAL_WITH_DELIMITERS = Pattern.compile( + "(\\d{4}|\\d{2})\\p{Punct}(([0])?[1-9]|[1][0-2])\\p{Punct}(([0])?[1-9]|[1-2]\\d|[3][0-1])[ T](([0-1])?\\d|[2][0-3])\\p{Punct}([0-5])?\\d(\\p{Punct}([0-5])?\\d(\\.\\d{1,9})?)?"); + public static final Pattern DATETIME_LITERAL_SHORT14 = Pattern + .compile("\\d{4}([0][1-9]|[1][0-2])([0][1-9]|[1-2]\\d|[3][0-1])([0-1]\\d|[2][0-3])([0-5]\\d){2}(\\.\\d{1,9}){0,1}"); + public static final Pattern DATETIME_LITERAL_SHORT12 = Pattern + .compile("\\d{2}([0][1-9]|[1][0-2])([0][1-9]|[1-2]\\d|[3][0-1])([0-1]\\d|[2][0-3])([0-5]\\d){2}(\\.\\d{1,9}){0,1}"); + + public static final Pattern DURATION_LITERAL_WITH_DAYS = Pattern + .compile("(-)?(([0-2])?\\d|[3][0-4]) (([0-1])?\\d|[2][0-3])(:([0-5])?\\d(:([0-5])?\\d(\\.\\d{1,9})?)?)?"); + public static final Pattern DURATION_LITERAL_NO_DAYS = Pattern.compile("(-)?\\d{1,3}:([0-5])?\\d(:([0-5])?\\d(\\.\\d{1,9})?)?"); + + // Mappings from TimeZone identifications (prefixed by type: Windows, TZ name, MetaZone, TZ alias, ...), to standard TimeZone Ids + private static final String TIME_ZONE_MAPPINGS_RESOURCE = "/com/mysql/cj/util/TimeZoneMapping.properties"; + + private static Properties timeZoneMappings = null; + + protected final static Method systemNanoTimeMethod; + + static { + Method aMethod; + + try { + aMethod = System.class.getMethod("nanoTime", (Class[]) null); + } catch (SecurityException e) { + aMethod = null; + } catch (NoSuchMethodException e) { + aMethod = null; + } + + systemNanoTimeMethod = aMethod; + } + + public static boolean nanoTimeAvailable() { + return systemNanoTimeMethod != null; + } + + public static long getCurrentTimeNanosOrMillis() { + if (systemNanoTimeMethod != null) { + try { + return ((Long) systemNanoTimeMethod.invoke(null, (Object[]) null)).longValue(); + } catch (IllegalArgumentException e) { + // ignore - fall through to currentTimeMillis() + } catch (IllegalAccessException e) { + // ignore - fall through to currentTimeMillis() + } catch (InvocationTargetException e) { + // ignore - fall through to currentTimeMillis() + } + } + + return System.currentTimeMillis(); + } + + /** + * Returns the 'official' Java timezone name for the given timezone + * + * @param timezoneStr + * the 'common' timezone name + * @param exceptionInterceptor + * exception interceptor + * + * @return the Java timezone name for the given timezone + */ + public static String getCanonicalTimeZone(String timezoneStr, ExceptionInterceptor exceptionInterceptor) { + if (timezoneStr == null) { + return null; + } + + timezoneStr = timezoneStr.trim(); + + // handle '+/-hh:mm' form ... + if (timezoneStr.length() > 2) { + if ((timezoneStr.charAt(0) == '+' || timezoneStr.charAt(0) == '-') && Character.isDigit(timezoneStr.charAt(1))) { + return "GMT" + timezoneStr; + } + } + + synchronized (TimeUtil.class) { + if (timeZoneMappings == null) { + loadTimeZoneMappings(exceptionInterceptor); + } + } + + String canonicalTz; + if ((canonicalTz = timeZoneMappings.getProperty(timezoneStr)) != null) { + return canonicalTz; + } + + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, + Messages.getString("TimeUtil.UnrecognizedTimeZoneId", new Object[] { timezoneStr }), exceptionInterceptor); + } + + /** + * Return a new Timestamp object which value is adjusted according to known DATE, DATETIME or TIMESTAMP field precision. + * + * @param ts + * an original Timestamp object, not modified by this method + * @param fsp + * value in the range from 0 to 6 specifying fractional seconds precision + * @param serverRoundFracSecs + * Flag indicating whether rounding or truncation occurs on server when inserting a TIME, DATE, or TIMESTAMP value with a fractional seconds part + * into a column having the same type but fewer fractional digits: true means rounding, false means truncation. The proper value should be + * detected by analyzing sql_mode server variable for TIME_TRUNCATE_FRACTIONAL presence. + * @return A new Timestamp object cloned from the original one and then rounded or truncated according to required fsp value + */ + public static Timestamp adjustNanosPrecision(Timestamp ts, int fsp, boolean serverRoundFracSecs) { + if (fsp < 0 || fsp > 6) { + throw ExceptionFactory.createException(WrongArgumentException.class, "fsp value must be in 0 to 6 range."); + } + Timestamp res = (Timestamp) ts.clone(); + double tail = Math.pow(10, 9 - fsp); + int nanos = serverRoundFracSecs ? (int) Math.round(res.getNanos() / tail) * (int) tail : (int) (res.getNanos() / tail) * (int) tail; + if (nanos > 999999999) { // if rounded up to the second then increment seconds + nanos %= 1000000000; // get last 9 digits + res.setTime(res.getTime() + 1000); // increment seconds + } + res.setNanos(nanos); + return res; + } + + /** + * Return a new LocalDateTime object which value is adjusted according to known DATE, DATETIME or TIMESTAMP field precision. + * + * @param x + * an original LocalDateTime object, not modified by this method + * @param fsp + * value in the range from 0 to 6 specifying fractional seconds precision + * @param serverRoundFracSecs + * Flag indicating whether rounding or truncation occurs on server when inserting a TIME, DATE, or TIMESTAMP value with a fractional seconds part + * into a column having the same type but fewer fractional digits: true means rounding, false means truncation. The proper value should be + * detected by analyzing sql_mode server variable for TIME_TRUNCATE_FRACTIONAL presence. + * @return A new LocalDateTime object cloned from the original one and then rounded or truncated according to required fsp value + */ + public static LocalDateTime adjustNanosPrecision(LocalDateTime x, int fsp, boolean serverRoundFracSecs) { + if (fsp < 0 || fsp > 6) { + throw ExceptionFactory.createException(WrongArgumentException.class, "fsp value must be in 0 to 6 range."); + } + int originalNano = x.getNano(); + double tail = Math.pow(10, 9 - fsp); + + int adjustedNano = serverRoundFracSecs ? (int) Math.round(originalNano / tail) * (int) tail : (int) (originalNano / tail) * (int) tail; + if (adjustedNano > 999999999) { // if rounded up to the second then increment seconds + adjustedNano %= 1000000000; + x = x.plusSeconds(1); + } + return x.withNano(adjustedNano); + } + + public static LocalTime adjustNanosPrecision(LocalTime x, int fsp, boolean serverRoundFracSecs) { + if (fsp < 0 || fsp > 6) { + throw ExceptionFactory.createException(WrongArgumentException.class, "fsp value must be in 0 to 6 range."); + } + int originalNano = x.getNano(); + double tail = Math.pow(10, 9 - fsp); + + int adjustedNano = serverRoundFracSecs ? (int) Math.round(originalNano / tail) * (int) tail : (int) (originalNano / tail) * (int) tail; + if (adjustedNano > 999999999) { // if rounded up to the second then increment seconds + adjustedNano %= 1000000000; + x = x.plusSeconds(1); + } + return x.withNano(adjustedNano); + } + + public static Duration adjustNanosPrecision(Duration x, int fsp, boolean serverRoundFracSecs) { + if (fsp < 0 || fsp > 6) { + throw ExceptionFactory.createException(WrongArgumentException.class, "fsp value must be in 0 to 6 range."); + } + int originalNano = x.getNano(); + double tail = Math.pow(10, 9 - fsp); + + int adjustedNano = serverRoundFracSecs ? (int) Math.round(originalNano / tail) * (int) tail : (int) (originalNano / tail) * (int) tail; + if (adjustedNano > 999999999) { // if rounded up to the second then increment seconds + adjustedNano %= 1000000000; + x = x.plusSeconds(1); + } + return x.withNanos(adjustedNano); + } + + /** + * Return a string representation of a fractional seconds part. This method assumes that all Timestamp adjustments are already done before, + * thus no rounding is needed, only a proper "0" padding to be done. + * + * @param nanos + * fractional seconds value + * @param fsp + * required fractional part length + * @return fractional seconds part as a string + */ + public static String formatNanos(int nanos, int fsp) { + return formatNanos(nanos, fsp, true); + } + + /** + * Return a string representation of a fractional seconds part. This method assumes that all Timestamp adjustments are already done before, + * thus no rounding is needed, only a proper "0" padding to be done. + * + * @param nanos + * fractional seconds value + * @param fsp + * required fractional part length + * @param truncateTrailingZeros + * whether to remove trailing zero characters in a fractional part after formatting + * @return fractional seconds part as a string + */ + public static String formatNanos(int nanos, int fsp, boolean truncateTrailingZeros) { + if (nanos < 0 || nanos > 999999999) { + throw ExceptionFactory.createException(WrongArgumentException.class, "nanos value must be in 0 to 999999999 range but was " + nanos); + } + if (fsp < 0 || fsp > 6) { + throw ExceptionFactory.createException(WrongArgumentException.class, "fsp value must be in 0 to 6 range but was " + fsp); + } + + if (fsp == 0 || nanos == 0) { + return "0"; + } + + // just truncate because we expect the rounding was done before + nanos = (int) (nanos / Math.pow(10, 9 - fsp)); + if (nanos == 0) { + return "0"; + } + + String nanosString = Integer.toString(nanos); + final String zeroPadding = "000000000"; + + nanosString = zeroPadding.substring(0, fsp - nanosString.length()) + nanosString; + + if (truncateTrailingZeros) { + int pos = fsp - 1; // the end, we're padded to the end by the code above + while (nanosString.charAt(pos) == '0') { + pos--; + } + nanosString = nanosString.substring(0, pos + 1); + } + return nanosString; + } + + /** + * Loads a properties file that contains all kinds of time zone mappings. + * + * @param exceptionInterceptor + * exception interceptor + */ + private static void loadTimeZoneMappings(ExceptionInterceptor exceptionInterceptor) { + timeZoneMappings = new Properties(); + try { + timeZoneMappings.load(TimeUtil.class.getResourceAsStream(TIME_ZONE_MAPPINGS_RESOURCE)); + } catch (IOException e) { + throw ExceptionFactory.createException(Messages.getString("TimeUtil.LoadTimeZoneMappingError"), exceptionInterceptor); + } + // bridge all Time Zone ids known by Java + for (String tz : TimeZone.getAvailableIDs()) { + if (!timeZoneMappings.containsKey(tz)) { + timeZoneMappings.put(tz, tz); + } + } + } + + public static Timestamp truncateFractionalSeconds(Timestamp timestamp) { + Timestamp truncatedTimestamp = new Timestamp(timestamp.getTime()); + truncatedTimestamp.setNanos(0); + return truncatedTimestamp; + } + + public static Time truncateFractionalSeconds(Time time) { + Time truncatedTime = new Time((time.getTime() / 1000) * 1000); + return truncatedTime; + } + + public static Boolean hasFractionalSeconds(Time t) { + return t.getTime() % 1000 > 0; + } + + /** + * Get SimpleDateFormat with a default Calendar which TimeZone is replaced with the provided one. + *

+ * Note: The SimpleDateFormat object returned by this method contains a default Calendar with an altered TimeZone. It's safe to cache it between this method + * calls because the Calendar object itself is not altered. + * + * @param cachedSimpleDateFormat + * existing SimpleDateFormat to use instead of creating a new one + * @param pattern + * format pattern + * @param tz + * {@link TimeZone} object replacing the default one + * @return {@link SimpleDateFormat} object + */ + public static SimpleDateFormat getSimpleDateFormat(SimpleDateFormat cachedSimpleDateFormat, String pattern, TimeZone tz) { + SimpleDateFormat sdf = cachedSimpleDateFormat != null && cachedSimpleDateFormat.toPattern().equals(pattern) ? cachedSimpleDateFormat + : new SimpleDateFormat(pattern, Locale.US); + if (tz != null) { + sdf.setTimeZone(tz); + } + return sdf; + } + + /** + * Get SimpleDateFormat where a default Calendar is replaced with the provided one. + *

+ * Note: Don't cache the SimpleDateFormat object returned by this method. Other methods could rely on assumption that the cached SimpleDateFormat has a + * default Calendar and that it is safe to change only it's time zone (see {@link #getSimpleDateFormat(SimpleDateFormat, String, TimeZone)}. + * + * @param pattern + * format pattern + * @param cal + * {@link Calendar} object replacing the default one + * @return {@link SimpleDateFormat} object + */ + public static SimpleDateFormat getSimpleDateFormat(String pattern, Calendar cal) { + SimpleDateFormat sdf = new SimpleDateFormat(pattern, Locale.US); + if (cal != null) { + sdf.setCalendar(cal); + } + return sdf; + } + + public static Object parseToDateTimeObject(String s, MysqlType targetMysqlType) throws IOException { + if (DATE_LITERAL_WITH_DELIMITERS.matcher(s).matches()) { + return LocalDate.parse(getCanonicalDate(s), DateTimeFormatter.ISO_LOCAL_DATE); + + } else if (DATE_LITERAL_NO_DELIMITERS.matcher(s).matches() && !(targetMysqlType == MysqlType.TIME && TIME_LITERAL_SHORT6.matcher(s).matches())) { + return s.length() == 8 ? LocalDate.parse(s, DateTimeFormatter.BASIC_ISO_DATE) : LocalDate.parse(s, DateTimeFormatter.ofPattern("yyMMdd")); + + } else if (TIME_LITERAL_WITH_DELIMITERS.matcher(s).matches()) { + return LocalTime.parse(getCanonicalTime(s), + new DateTimeFormatterBuilder().appendPattern("HH:mm:ss").appendFraction(ChronoField.NANO_OF_SECOND, 0, 9, true).toFormatter()); + + } else if (TIME_LITERAL_SHORT6.matcher(s).matches()) { + return LocalTime.parse(s, + new DateTimeFormatterBuilder().appendPattern("HHmmss").appendFraction(ChronoField.NANO_OF_SECOND, 0, 9, true).toFormatter()); + + } else if (TIME_LITERAL_SHORT4.matcher(s).matches()) { + return LocalTime.parse("00" + s, + new DateTimeFormatterBuilder().appendPattern("HHmmss").appendFraction(ChronoField.NANO_OF_SECOND, 0, 9, true).toFormatter()); + + } else if (TIME_LITERAL_SHORT2.matcher(s).matches()) { + return LocalTime.parse("0000" + s, + new DateTimeFormatterBuilder().appendPattern("HHmmss").appendFraction(ChronoField.NANO_OF_SECOND, 0, 9, true).toFormatter()); + + } else if (DATETIME_LITERAL_SHORT14.matcher(s).matches()) { + return LocalDateTime.parse(s, + new DateTimeFormatterBuilder().appendPattern("yyyyMMddHHmmss").appendFraction(ChronoField.NANO_OF_SECOND, 0, 9, true).toFormatter()); + + } else if (DATETIME_LITERAL_SHORT12.matcher(s).matches()) { + return LocalDateTime.parse(s, + new DateTimeFormatterBuilder().appendPattern("yyMMddHHmmss").appendFraction(ChronoField.NANO_OF_SECOND, 0, 9, true).toFormatter()); + + } else if (DATETIME_LITERAL_WITH_DELIMITERS.matcher(s).matches()) { + return LocalDateTime.parse(getCanonicalDateTime(s), + new DateTimeFormatterBuilder().appendPattern("yyyy-MM-dd HH:mm:ss").appendFraction(ChronoField.NANO_OF_SECOND, 0, 9, true).toFormatter()); + + } else if (DURATION_LITERAL_WITH_DAYS.matcher(s).matches() || DURATION_LITERAL_NO_DAYS.matcher(s).matches()) { + s = s.startsWith("-") ? s.replace("-", "-P") : "P" + s; + s = s.contains(" ") ? s.replace(" ", "DT") : s.replace("P", "PT"); + String[] ch = new String[] { "H", "M", "S" }; + int pos = 0; + while (s.contains(":")) { + s = s.replaceFirst(":", ch[pos++]); + } + s = s + ch[pos]; + return Duration.parse(s); + } + throw ExceptionFactory.createException(WrongArgumentException.class, "There is no known date-time pattern for '" + s + "' value"); + } + + private static String getCanonicalDate(String s) { + String[] sa = s.split("\\p{Punct}"); + StringBuilder sb = new StringBuilder(); + if (sa[0].length() == 2) { + sb.append(Integer.valueOf(sa[0]) > 69 ? "19" : "20"); + } + sb.append(sa[0]); + sb.append("-"); + if (sa[1].length() == 1) { + sb.append("0"); + } + sb.append(sa[1]); + sb.append("-"); + if (sa[2].length() == 1) { + sb.append("0"); + } + sb.append(sa[2]); + + return sb.toString(); + } + + private static String getCanonicalTime(String s) { + String[] sa = s.split("\\p{Punct}"); + StringBuilder sb = new StringBuilder(); + + for (int i = 0; i < sa.length; i++) { + if (i > 0) { + sb.append(i < 3 ? ":" : "."); + } + if (i < 3 && sa[i].length() == 1) { + sb.append("0"); + } + sb.append(sa[i]); + + } + if (sa.length < 3) { + sb.append(":00"); + } + + return sb.toString(); + } + + private static String getCanonicalDateTime(String s) { + String[] sa = s.split("[ T]"); + StringBuilder sb = new StringBuilder(); + sb.append(getCanonicalDate(sa[0])); + sb.append(" "); + sb.append(getCanonicalTime(sa[1])); + return sb.toString(); + } + + public static String getDurationString(Duration x) { + String s = (x.isNegative() ? "-" + x.abs().toString() : x.toString()).replace("PT", ""); + if (s.contains("M")) { + s = s.replace("H", ":"); + if (s.contains("S")) { + s = s.replace("M", ":").replace("S", ""); + } else { + s = s.replace("M", ":0"); + } + } else { + s = s.replace("H", ":0:0"); + } + return s; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/Util.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/Util.java new file mode 100644 index 0000000..c3a49a3 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-api/java/com/mysql/cj/util/Util.java @@ -0,0 +1,507 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.util; + +import java.io.IOException; +import java.io.InputStream; +import java.io.PrintWriter; +import java.io.Reader; +import java.io.StringWriter; +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.util.Collections; +import java.util.HashMap; +import java.util.LinkedHashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ConcurrentMap; + +import com.mysql.cj.Constants; +import com.mysql.cj.Messages; +import com.mysql.cj.exceptions.CJException; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.ExceptionInterceptor; +import com.mysql.cj.exceptions.WrongArgumentException; + +/** + * Various utility methods for the driver. + */ +public class Util { + private static int jvmVersion = 8; // use default base version supported + + private static int jvmUpdateNumber = -1; + + static { + int startPos = Constants.JVM_VERSION.indexOf('.'); + int endPos = startPos + 1; + if (startPos != -1) { + while (Character.isDigit(Constants.JVM_VERSION.charAt(endPos)) && ++endPos < Constants.JVM_VERSION.length()) { + // continue + } + } + startPos++; + if (endPos > startPos) { + jvmVersion = Integer.parseInt(Constants.JVM_VERSION.substring(startPos, endPos)); + } + startPos = Constants.JVM_VERSION.indexOf("_"); + endPos = startPos + 1; + if (startPos != -1) { + while (Character.isDigit(Constants.JVM_VERSION.charAt(endPos)) && ++endPos < Constants.JVM_VERSION.length()) { + // continue + } + } + startPos++; + if (endPos > startPos) { + jvmUpdateNumber = Integer.parseInt(Constants.JVM_VERSION.substring(startPos, endPos)); + } + + } + + public static int getJVMVersion() { + return jvmVersion; + } + + public static boolean jvmMeetsMinimum(int version, int updateNumber) { + return getJVMVersion() > version || getJVMVersion() == version && getJVMUpdateNumber() >= updateNumber; + } + + public static int getJVMUpdateNumber() { + return jvmUpdateNumber; + } + + /** + * Checks whether the given server version string is a MySQL Community edition + * + * @param serverVersion + * full server version string + * @return true if version does not contain "enterprise", "commercial" or "advanced" + */ + public static boolean isCommunityEdition(String serverVersion) { + return !isEnterpriseEdition(serverVersion); + } + + /** + * Checks whether the given server version string is a MySQL Enterprise edition + * + * @param serverVersion + * full server version string + * @return true if version contains "enterprise", "commercial" or "advanced" + */ + public static boolean isEnterpriseEdition(String serverVersion) { + return serverVersion.contains("enterprise") || serverVersion.contains("commercial") || serverVersion.contains("advanced"); + } + + /** + * Converts a nested exception into a nicer message + * + * @param ex + * the exception to expand into a message. + * + * @return a message containing the exception, the message (if any), and a + * stacktrace. + */ + public static String stackTraceToString(Throwable ex) { + StringBuilder traceBuf = new StringBuilder(); + traceBuf.append(Messages.getString("Util.1")); + + if (ex != null) { + traceBuf.append(ex.getClass().getName()); + + String message = ex.getMessage(); + + if (message != null) { + traceBuf.append(Messages.getString("Util.2")); + traceBuf.append(message); + } + + StringWriter out = new StringWriter(); + + PrintWriter printOut = new PrintWriter(out); + + ex.printStackTrace(printOut); + + traceBuf.append(Messages.getString("Util.3")); + traceBuf.append(out.toString()); + } + + traceBuf.append(Messages.getString("Util.4")); + + return traceBuf.toString(); + } + + public static Object getInstance(String className, Class[] argTypes, Object[] args, ExceptionInterceptor exceptionInterceptor, String errorMessage) { + + try { + return handleNewInstance(Class.forName(className).getConstructor(argTypes), args, exceptionInterceptor); + } catch (SecurityException | NoSuchMethodException | ClassNotFoundException e) { + throw ExceptionFactory.createException(WrongArgumentException.class, errorMessage, e, exceptionInterceptor); + } + } + + public static Object getInstance(String className, Class[] argTypes, Object[] args, ExceptionInterceptor exceptionInterceptor) { + return getInstance(className, argTypes, args, exceptionInterceptor, "Can't instantiate required class"); + } + + /** + * Handles constructing new instance with the given constructor and wrapping + * (or not, as required) the exceptions that could possibly be generated + * + * @param ctor + * constructor + * @param args + * arguments for constructor + * @param exceptionInterceptor + * exception interceptor + * @return object + */ + public static Object handleNewInstance(Constructor ctor, Object[] args, ExceptionInterceptor exceptionInterceptor) { + try { + + return ctor.newInstance(args); + } catch (IllegalArgumentException | InstantiationException | IllegalAccessException e) { + throw ExceptionFactory.createException(WrongArgumentException.class, "Can't instantiate required class", e, exceptionInterceptor); + } catch (InvocationTargetException e) { + Throwable target = e.getTargetException(); + + if (target instanceof ExceptionInInitializerError) { + target = ((ExceptionInInitializerError) target).getException(); + } else if (target instanceof CJException) { + throw (CJException) target; + } + + throw ExceptionFactory.createException(WrongArgumentException.class, target.getMessage(), target, exceptionInterceptor); + } + } + + /** + * Does a network interface exist locally with the given hostname? + * + * @param hostname + * the hostname (or IP address in string form) to check + * @return true if it exists, false if no, or unable to determine due to VM + * version support of java.net.NetworkInterface + */ + public static boolean interfaceExists(String hostname) { + try { + Class networkInterfaceClass = Class.forName("java.net.NetworkInterface"); + return networkInterfaceClass.getMethod("getByName", (Class[]) null).invoke(networkInterfaceClass, new Object[] { hostname }) != null; + } catch (Throwable t) { + return false; + } + } + + public static Map calculateDifferences(Map map1, Map map2) { + Map diffMap = new HashMap<>(); + + for (Map.Entry entry : map1.entrySet()) { + Object key = entry.getKey(); + + Number value1 = null; + Number value2 = null; + + if (entry.getValue() instanceof Number) { + + value1 = (Number) entry.getValue(); + value2 = (Number) map2.get(key); + } else { + try { + value1 = new Double(entry.getValue().toString()); + value2 = new Double(map2.get(key).toString()); + } catch (NumberFormatException nfe) { + continue; + } + } + + if (value1.equals(value2)) { + continue; + } + + if (value1 instanceof Byte) { + diffMap.put(key, Byte.valueOf((byte) (((Byte) value2).byteValue() - ((Byte) value1).byteValue()))); + } else if (value1 instanceof Short) { + diffMap.put(key, Short.valueOf((short) (((Short) value2).shortValue() - ((Short) value1).shortValue()))); + } else if (value1 instanceof Integer) { + diffMap.put(key, Integer.valueOf((((Integer) value2).intValue() - ((Integer) value1).intValue()))); + } else if (value1 instanceof Long) { + diffMap.put(key, Long.valueOf((((Long) value2).longValue() - ((Long) value1).longValue()))); + } else if (value1 instanceof Float) { + diffMap.put(key, Float.valueOf(((Float) value2).floatValue() - ((Float) value1).floatValue())); + } else if (value1 instanceof Double) { + diffMap.put(key, Double.valueOf((((Double) value2).shortValue() - ((Double) value1).shortValue()))); + } else if (value1 instanceof BigDecimal) { + diffMap.put(key, ((BigDecimal) value2).subtract((BigDecimal) value1)); + } else if (value1 instanceof BigInteger) { + diffMap.put(key, ((BigInteger) value2).subtract((BigInteger) value1)); + } + } + + return diffMap; + } + + public static List loadClasses(String extensionClassNames, String errorMessageKey, ExceptionInterceptor exceptionInterceptor) { + + List instances = new LinkedList<>(); + + List interceptorsToCreate = StringUtils.split(extensionClassNames, ",", true); + + String className = null; + + try { + for (int i = 0, s = interceptorsToCreate.size(); i < s; i++) { + className = interceptorsToCreate.get(i); + @SuppressWarnings("unchecked") + T instance = (T) Class.forName(className).newInstance(); + + instances.add(instance); + } + + } catch (Throwable t) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString(errorMessageKey, new Object[] { className }), t, + exceptionInterceptor); + } + + return instances; + } + + /** Cache for the JDBC interfaces already verified */ + private static final ConcurrentMap, Boolean> isJdbcInterfaceCache = new ConcurrentHashMap<>(); + + /** + * Recursively checks for interfaces on the given class to determine if it implements a java.sql, javax.sql or com.mysql.cj.jdbc interface. + * + * @param clazz + * The class to investigate. + * @return boolean + */ + public static boolean isJdbcInterface(Class clazz) { + if (Util.isJdbcInterfaceCache.containsKey(clazz)) { + return (Util.isJdbcInterfaceCache.get(clazz)); + } + + if (clazz.isInterface()) { + try { + if (isJdbcPackage(clazz.getPackage().getName())) { + Util.isJdbcInterfaceCache.putIfAbsent(clazz, true); + return true; + } + } catch (Exception ex) { + /* + * We may experience a NPE from getPackage() returning null, or class-loading facilities. + * This happens when this class is instrumented to implement runtime-generated interfaces. + */ + } + } + + for (Class iface : clazz.getInterfaces()) { + if (isJdbcInterface(iface)) { + Util.isJdbcInterfaceCache.putIfAbsent(clazz, true); + return true; + } + } + + if (clazz.getSuperclass() != null && isJdbcInterface(clazz.getSuperclass())) { + Util.isJdbcInterfaceCache.putIfAbsent(clazz, true); + return true; + } + + Util.isJdbcInterfaceCache.putIfAbsent(clazz, false); + return false; + } + + /** + * Check if the package name is a known JDBC package. + * + * @param packageName + * The package name to check. + * @return boolean + */ + public static boolean isJdbcPackage(String packageName) { + return packageName != null + && (packageName.startsWith("java.sql") || packageName.startsWith("javax.sql") || packageName.startsWith("com.mysql.cj.jdbc")); + } + + /** Cache for the implemented interfaces searched. */ + private static final ConcurrentMap, Class[]> implementedInterfacesCache = new ConcurrentHashMap<>(); + + /** + * Retrieves a list with all interfaces implemented by the given class. If possible gets this information from a cache instead of navigating through the + * object hierarchy. Results are stored in a cache for future reference. + * + * @param clazz + * The class from which the interface list will be retrieved. + * @return + * An array with all the interfaces for the given class. + */ + public static Class[] getImplementedInterfaces(Class clazz) { + Class[] implementedInterfaces = Util.implementedInterfacesCache.get(clazz); + if (implementedInterfaces != null) { + return implementedInterfaces; + } + + Set> interfaces = new LinkedHashSet<>(); + Class superClass = clazz; + do { + Collections.addAll(interfaces, superClass.getInterfaces()); + } while ((superClass = superClass.getSuperclass()) != null); + + implementedInterfaces = interfaces.toArray(new Class[interfaces.size()]); + Class[] oldValue = Util.implementedInterfacesCache.putIfAbsent(clazz, implementedInterfaces); + if (oldValue != null) { + implementedInterfaces = oldValue; + } + + return implementedInterfaces; + } + + /** + * Computes the number of seconds elapsed since the given time in milliseconds. + * + * @param timeInMillis + * The past instant in milliseconds. + * @return + * The number of seconds, truncated, elapsed since timeInMillis. + */ + public static long secondsSinceMillis(long timeInMillis) { + return (System.currentTimeMillis() - timeInMillis) / 1000; + } + + /** + * Converts long to int, truncating to maximum/minimum value if needed. + * + * @param longValue + * long value + * @return int value + */ + public static int truncateAndConvertToInt(long longValue) { + return longValue > Integer.MAX_VALUE ? Integer.MAX_VALUE : longValue < Integer.MIN_VALUE ? Integer.MIN_VALUE : (int) longValue; + } + + /** + * Converts long[] to int[], truncating to maximum/minimum value if needed. + * + * @param longArray + * log values + * @return int values + */ + public static int[] truncateAndConvertToInt(long[] longArray) { + int[] intArray = new int[longArray.length]; + + for (int i = 0; i < longArray.length; i++) { + intArray[i] = longArray[i] > Integer.MAX_VALUE ? Integer.MAX_VALUE : longArray[i] < Integer.MIN_VALUE ? Integer.MIN_VALUE : (int) longArray[i]; + } + return intArray; + } + + /** + * Returns the package name of the given class. + * Using clazz.getPackage().getName() is not an alternative because under some class loaders the method getPackage() just returns null. + * + * @param clazz + * the Class from which to get the package name + * @return the package name + */ + public static String getPackageName(Class clazz) { + String fqcn = clazz.getName(); + int classNameStartsAt = fqcn.lastIndexOf('.'); + if (classNameStartsAt > 0) { + return fqcn.substring(0, classNameStartsAt); + } + return ""; + } + + /** + * Checks if the JVM is running on Windows Operating System. + * + * @return + * true if currently running on Windows, false otherwise. + */ + public static boolean isRunningOnWindows() { + return StringUtils.indexOfIgnoreCase(Constants.OS_NAME, "WINDOWS") != -1; + } + + /** + * Reads length bytes from reader into buf. Blocks until enough input is + * available + * + * @param reader + * {@link Reader} + * @param buf + * char array to read into + * @param length + * number of chars to read + * + * @return the actual number of chars read + * + * @throws IOException + * if an error occurs + */ + public static int readFully(Reader reader, char[] buf, int length) throws IOException { + int numCharsRead = 0; + + while (numCharsRead < length) { + int count = reader.read(buf, numCharsRead, length - numCharsRead); + + if (count < 0) { + break; + } + + numCharsRead += count; + } + + return numCharsRead; + } + + public static final int readBlock(InputStream i, byte[] b, ExceptionInterceptor exceptionInterceptor) { + try { + return i.read(b); + } catch (Throwable ex) { + throw ExceptionFactory.createException(Messages.getString("Util.5") + ex.getClass().getName(), exceptionInterceptor); + } + } + + public static final int readBlock(InputStream i, byte[] b, int length, ExceptionInterceptor exceptionInterceptor) { + try { + int lengthToRead = length; + + if (lengthToRead > b.length) { + lengthToRead = b.length; + } + + return i.read(b, 0, lengthToRead); + } catch (Throwable ex) { + throw ExceptionFactory.createException(Messages.getString("Util.5") + ex.getClass().getName(), exceptionInterceptor); + } + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/AbstractPreparedQuery.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/AbstractPreparedQuery.java new file mode 100644 index 0000000..bdc9046 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/AbstractPreparedQuery.java @@ -0,0 +1,422 @@ +/* + * Copyright (c) 2017, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.io.IOException; +import java.io.InputStream; + +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.conf.RuntimeProperty; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.WrongArgumentException; +import com.mysql.cj.protocol.Message; +import com.mysql.cj.protocol.a.NativeConstants; +import com.mysql.cj.protocol.a.NativeConstants.IntegerDataType; +import com.mysql.cj.protocol.a.NativeConstants.StringLengthDataType; +import com.mysql.cj.protocol.a.NativeConstants.StringSelfDataType; +import com.mysql.cj.protocol.a.NativePacketPayload; +import com.mysql.cj.protocol.a.ValueEncoder; +import com.mysql.cj.util.StringUtils; +import com.mysql.cj.util.Util; + +// TODO should not be protocol-specific +public abstract class AbstractPreparedQuery> extends AbstractQuery implements PreparedQuery { + + protected ParseInfo parseInfo; + + protected T queryBindings = null; + + /** The SQL that was passed in to 'prepare' */ + protected String originalSql = null; + + /** The number of parameters in this PreparedStatement */ + protected int parameterCount; + + protected RuntimeProperty autoClosePStmtStreams; + + /** Command index of currently executing batch command. */ + protected int batchCommandIndex = -1; + + protected RuntimeProperty useStreamLengthsInPrepStmts; + + private byte[] streamConvertBuf = null; + + private boolean usingAnsiMode; + + public AbstractPreparedQuery(NativeSession sess) { + super(sess); + + this.autoClosePStmtStreams = this.session.getPropertySet().getBooleanProperty(PropertyKey.autoClosePStmtStreams); + this.useStreamLengthsInPrepStmts = this.session.getPropertySet().getBooleanProperty(PropertyKey.useStreamLengthsInPrepStmts); + this.usingAnsiMode = !this.session.getServerSession().useAnsiQuotedIdentifiers(); + } + + @Override + public void closeQuery() { + this.streamConvertBuf = null; + super.closeQuery(); + } + + public ParseInfo getParseInfo() { + return this.parseInfo; + } + + public void setParseInfo(ParseInfo parseInfo) { + this.parseInfo = parseInfo; + } + + public String getOriginalSql() { + return this.originalSql; + } + + public void setOriginalSql(String originalSql) { + this.originalSql = originalSql; + } + + public int getParameterCount() { + return this.parameterCount; + } + + public void setParameterCount(int parameterCount) { + this.parameterCount = parameterCount; + } + + @Override + public T getQueryBindings() { + return this.queryBindings; + } + + @Override + public void setQueryBindings(T queryBindings) { + this.queryBindings = queryBindings; + } + + public int getBatchCommandIndex() { + return this.batchCommandIndex; + } + + public void setBatchCommandIndex(int batchCommandIndex) { + this.batchCommandIndex = batchCommandIndex; + } + + /** + * Computes the optimum number of batched parameter lists to send + * without overflowing max_allowed_packet. + * + * @param numBatchedArgs + * original batch size + * @return computed batch size + */ + public int computeBatchSize(int numBatchedArgs) { + long[] combinedValues = computeMaxParameterSetSizeAndBatchSize(numBatchedArgs); + + long maxSizeOfParameterSet = combinedValues[0]; + long sizeOfEntireBatch = combinedValues[1]; + + if (sizeOfEntireBatch < this.maxAllowedPacket.getValue() - this.originalSql.length()) { + return numBatchedArgs; + } + + return (int) Math.max(1, (this.maxAllowedPacket.getValue() - this.originalSql.length()) / maxSizeOfParameterSet); + } + + /** + * Method checkNullOrEmptyQuery. + * + * @param sql + * the SQL to check + * + * @throws WrongArgumentException + * if query is null or empty. + */ + public void checkNullOrEmptyQuery(String sql) { + if (sql == null) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("PreparedQuery.0"), this.session.getExceptionInterceptor()); + } + + if (sql.length() == 0) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("PreparedQuery.1"), this.session.getExceptionInterceptor()); + } + } + + public String asSql() { + return asSql(false); + } + + public String asSql(boolean quoteStreamsAndUnknowns) { + StringBuilder buf = new StringBuilder(); + + Object batchArg = null; + if (this.batchCommandIndex != -1) { + batchArg = this.batchedArgs.get(this.batchCommandIndex); + } + + byte[][] staticSqlStrings = this.parseInfo.getStaticSql(); + for (int i = 0; i < this.parameterCount; ++i) { + buf.append(this.charEncoding != null ? StringUtils.toString(staticSqlStrings[i], this.charEncoding) : StringUtils.toString(staticSqlStrings[i])); + + byte val[] = null; + if (batchArg != null && batchArg instanceof String) { + buf.append((String) batchArg); + continue; + } + val = this.batchCommandIndex == -1 ? (this.queryBindings == null ? null : this.queryBindings.getBindValues()[i].getByteValue()) + : ((QueryBindings) batchArg).getBindValues()[i].getByteValue(); + + boolean isStreamParam = this.batchCommandIndex == -1 ? (this.queryBindings == null ? false : this.queryBindings.getBindValues()[i].isStream()) + : ((QueryBindings) batchArg).getBindValues()[i].isStream(); + + if ((val == null) && !isStreamParam) { + buf.append(quoteStreamsAndUnknowns ? "'** NOT SPECIFIED **'" : "** NOT SPECIFIED **"); + } else if (isStreamParam) { + buf.append(quoteStreamsAndUnknowns ? "'** STREAM DATA **'" : "** STREAM DATA **"); + } else { + buf.append(StringUtils.toString(val, this.charEncoding)); + } + } + + buf.append(this.charEncoding != null ? StringUtils.toString(staticSqlStrings[this.parameterCount], this.charEncoding) + : StringUtils.toAsciiString(staticSqlStrings[this.parameterCount])); + + return buf.toString(); + } + + protected abstract long[] computeMaxParameterSetSizeAndBatchSize(int numBatchedArgs); + + /** + * Creates the packet that contains the query to be sent to the server. + * + * @return A Buffer filled with the query representing the + * PreparedStatement. + */ + @Override + public M fillSendPacket() { + synchronized (this) { + return fillSendPacket(this.queryBindings); + } + } + + /** + * Creates the packet that contains the query to be sent to the server. + * + * @param bindings + * values + * + * @return a Buffer filled with the query that represents this statement + */ + @SuppressWarnings("unchecked") + @Override + public M fillSendPacket(QueryBindings bindings) { + // TODO this method is specific to CSPS and the native protocol; must be unified with SSPS via message builder + + synchronized (this) { + BindValue[] bindValues = bindings.getBindValues(); + + NativePacketPayload sendPacket = this.session.getSharedSendPacket(); + + sendPacket.writeInteger(IntegerDataType.INT1, NativeConstants.COM_QUERY); + + if (getSession().getServerSession().supportsQueryAttributes()) { + if (this.queryAttributesBindings.getCount() > 0) { + sendPacket.writeInteger(IntegerDataType.INT_LENENC, this.queryAttributesBindings.getCount()); + sendPacket.writeInteger(IntegerDataType.INT_LENENC, 1); // parameter_set_count (always 1) + byte[] nullBitsBuffer = new byte[(this.queryAttributesBindings.getCount() + 7) / 8]; + for (int i = 0; i < this.queryAttributesBindings.getCount(); i++) { + if (this.queryAttributesBindings.getAttributeValue(i).isNull()) { + nullBitsBuffer[i >>> 3] |= 1 << (i & 7); + } + } + sendPacket.writeBytes(StringLengthDataType.STRING_VAR, nullBitsBuffer); + sendPacket.writeInteger(IntegerDataType.INT1, 1); // new_params_bind_flag (always 1) + this.queryAttributesBindings.runThroughAll(a -> { + sendPacket.writeInteger(IntegerDataType.INT2, a.getType()); + sendPacket.writeBytes(StringSelfDataType.STRING_LENENC, a.getName().getBytes()); + }); + ValueEncoder valueEncoder = new ValueEncoder(sendPacket, this.charEncoding, this.session.getServerSession().getDefaultTimeZone()); + this.queryAttributesBindings.runThroughAll(a -> valueEncoder.encodeValue(a.getValue(), a.getType())); + } else { + sendPacket.writeInteger(IntegerDataType.INT_LENENC, 0); + sendPacket.writeInteger(IntegerDataType.INT_LENENC, 1); // parameter_set_count (always 1) + } + } else if (this.queryAttributesBindings.getCount() > 0) { + this.session.getLog().logWarn(Messages.getString("QueryAttributes.SetButNotSupported")); + } + + sendPacket.setTag("QUERY"); + + boolean useStreamLengths = this.useStreamLengthsInPrepStmts.getValue(); + + // + // Try and get this allocation as close as possible for BLOBs + // + int ensurePacketSize = 0; + + String statementComment = this.session.getProtocol().getQueryComment(); + + byte[] commentAsBytes = null; + + if (statementComment != null) { + commentAsBytes = StringUtils.getBytes(statementComment, this.charEncoding); + + ensurePacketSize += commentAsBytes.length; + ensurePacketSize += 6; // for /*[space] [space]*/ + } + + for (int i = 0; i < bindValues.length; i++) { + if (bindValues[i].isStream() && useStreamLengths) { + ensurePacketSize += bindValues[i].getStreamLength(); + } + } + + if (ensurePacketSize != 0) { + sendPacket.ensureCapacity(ensurePacketSize); + } + + if (commentAsBytes != null) { + sendPacket.writeBytes(StringLengthDataType.STRING_FIXED, Constants.SLASH_STAR_SPACE_AS_BYTES); + sendPacket.writeBytes(StringLengthDataType.STRING_FIXED, commentAsBytes); + sendPacket.writeBytes(StringLengthDataType.STRING_FIXED, Constants.SPACE_STAR_SLASH_SPACE_AS_BYTES); + } + + byte[][] staticSqlStrings = this.parseInfo.getStaticSql(); + for (int i = 0; i < bindValues.length; i++) { + bindings.checkParameterSet(i); + + sendPacket.writeBytes(StringLengthDataType.STRING_FIXED, staticSqlStrings[i]); + + if (bindValues[i].isStream()) { + streamToBytes(sendPacket, bindValues[i].getStreamValue(), true, bindValues[i].getStreamLength(), useStreamLengths); + } else { + sendPacket.writeBytes(StringLengthDataType.STRING_FIXED, bindValues[i].getByteValue()); + } + } + + sendPacket.writeBytes(StringLengthDataType.STRING_FIXED, staticSqlStrings[bindValues.length]); + + return (M) sendPacket; + } + } + + private final void streamToBytes(NativePacketPayload packet, InputStream in, boolean escape, long streamLength, boolean useLength) { + // TODO this method should be unified with AbstractQueryBindings.streamToBytes() + try { + if (this.streamConvertBuf == null) { + this.streamConvertBuf = new byte[4096]; + } + + boolean hexEscape = this.session.getServerSession().isNoBackslashEscapesSet(); + + if (streamLength == -1) { + useLength = false; + } + + int bc = useLength ? Util.readBlock(in, this.streamConvertBuf, (int) streamLength, this.session.getExceptionInterceptor()) + : Util.readBlock(in, this.streamConvertBuf, this.session.getExceptionInterceptor()); + + int lengthLeftToRead = (int) streamLength - bc; + + packet.writeBytes(StringLengthDataType.STRING_FIXED, StringUtils.getBytes(hexEscape ? "x" : "_binary")); + + if (escape) { + packet.writeInteger(IntegerDataType.INT1, (byte) '\''); + } + + while (bc > 0) { + if (hexEscape) { + ((AbstractQueryBindings) this.queryBindings).hexEscapeBlock(this.streamConvertBuf, packet, bc); + } else if (escape) { + escapeblockFast(this.streamConvertBuf, packet, bc); + } else { + packet.writeBytes(StringLengthDataType.STRING_FIXED, this.streamConvertBuf, 0, bc); + } + + if (useLength) { + bc = Util.readBlock(in, this.streamConvertBuf, lengthLeftToRead, this.session.getExceptionInterceptor()); + + if (bc > 0) { + lengthLeftToRead -= bc; + } + } else { + bc = Util.readBlock(in, this.streamConvertBuf, this.session.getExceptionInterceptor()); + } + } + + if (escape) { + packet.writeInteger(IntegerDataType.INT1, (byte) '\''); + } + } finally { + if (this.autoClosePStmtStreams.getValue()) { + try { + in.close(); + } catch (IOException ioEx) { + } + + in = null; + } + } + } + + private final void escapeblockFast(byte[] buf, NativePacketPayload packet, int size) { + int lastwritten = 0; + + for (int i = 0; i < size; i++) { + byte b = buf[i]; + + if (b == '\0') { + // write stuff not yet written + if (i > lastwritten) { + packet.writeBytes(StringLengthDataType.STRING_FIXED, buf, lastwritten, i - lastwritten); + } + + // write escape + packet.writeInteger(IntegerDataType.INT1, (byte) '\\'); + packet.writeInteger(IntegerDataType.INT1, (byte) '0'); + lastwritten = i + 1; + } else { + if ((b == '\\') || (b == '\'') || (!this.usingAnsiMode && b == '"')) { + // write stuff not yet written + if (i > lastwritten) { + packet.writeBytes(StringLengthDataType.STRING_FIXED, buf, lastwritten, i - lastwritten); + } + + // write escape + packet.writeInteger(IntegerDataType.INT1, (byte) '\\'); + lastwritten = i; // not i+1 as b wasn't written. + } + } + } + + // write out remaining stuff from buffer + if (lastwritten < size) { + packet.writeBytes(StringLengthDataType.STRING_FIXED, buf, lastwritten, size - lastwritten); + } + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/AbstractQuery.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/AbstractQuery.java new file mode 100644 index 0000000..eb65aac --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/AbstractQuery.java @@ -0,0 +1,261 @@ +/* + * Copyright (c) 2017, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; +import java.util.concurrent.atomic.AtomicBoolean; + +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.conf.RuntimeProperty; +import com.mysql.cj.exceptions.CJException; +import com.mysql.cj.exceptions.CJTimeoutException; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.OperationCancelledException; +import com.mysql.cj.protocol.Message; +import com.mysql.cj.protocol.ProtocolEntityFactory; +import com.mysql.cj.protocol.Resultset; +import com.mysql.cj.protocol.Resultset.Type; + +//TODO should not be protocol-specific +public abstract class AbstractQuery implements Query { + + /** Used to generate IDs when profiling. */ + static int statementCounter = 1; + + public NativeSession session = null; + + /** Used to identify this statement when profiling. */ + protected int statementId; + + protected RuntimeProperty maxAllowedPacket; + + /** The character encoding to use (if available) */ + protected String charEncoding = null; + + /** Mutex to prevent race between returning query results and noticing that query has been timed-out or cancelled. */ + protected Object cancelTimeoutMutex = new Object(); + + private CancelStatus cancelStatus = CancelStatus.NOT_CANCELED; + + /** The timeout for a query */ + protected int timeoutInMillis = 0; + + /** Holds batched commands */ + protected List batchedArgs; + + /** The type of this result set (scroll sensitive or in-sensitive) */ + protected Resultset.Type resultSetType = Type.FORWARD_ONLY; + + /** The number of rows to fetch at a time (currently ignored) */ + protected int fetchSize = 0; + + /** Currently executing a statement? */ + protected final AtomicBoolean statementExecuting = new AtomicBoolean(false); + + /** The database in use */ + protected String currentDb = null; + + /** Has clearWarnings() been called? */ + protected boolean clearWarningsCalled = false; + + /** Elapsed time of the execution */ + private long executeTime = -1; + + /** Query attributes bindings */ + protected QueryAttributesBindings queryAttributesBindings; + + public AbstractQuery(NativeSession sess) { + statementCounter++; + this.session = sess; + this.maxAllowedPacket = sess.getPropertySet().getIntegerProperty(PropertyKey.maxAllowedPacket); + this.charEncoding = sess.getPropertySet().getStringProperty(PropertyKey.characterEncoding).getValue(); + this.queryAttributesBindings = new NativeQueryAttributesBindings(); + } + + @Override + public int getId() { + return this.statementId; + } + + @Override + public void setCancelStatus(CancelStatus cs) { + this.cancelStatus = cs; + } + + @Override + public long getExecuteTime() { + return this.executeTime; + } + + @Override + public void setExecuteTime(long executeTime) { + this.executeTime = executeTime; + } + + @Override + public void checkCancelTimeout() { + synchronized (this.cancelTimeoutMutex) { + if (this.cancelStatus != CancelStatus.NOT_CANCELED) { + CJException cause = this.cancelStatus == CancelStatus.CANCELED_BY_TIMEOUT ? new CJTimeoutException() : new OperationCancelledException(); + resetCancelledState(); + throw cause; + } + } + } + + public void resetCancelledState() { + synchronized (this.cancelTimeoutMutex) { + this.cancelStatus = CancelStatus.NOT_CANCELED; + } + } + + @Override + public ProtocolEntityFactory getResultSetFactory() { + // TODO Auto-generated method stub + return null; + } + + @Override + public NativeSession getSession() { + return this.session; + } + + @Override + public Object getCancelTimeoutMutex() { + return this.cancelTimeoutMutex; + } + + public void closeQuery() { + this.session = null; + } + + public void addBatch(Object batch) { + if (this.batchedArgs == null) { + this.batchedArgs = new ArrayList<>(); + } + this.batchedArgs.add(batch); + } + + public List getBatchedArgs() { + return this.batchedArgs == null ? null : Collections.unmodifiableList(this.batchedArgs); + } + + @Override + public void clearBatchedArgs() { + if (this.batchedArgs != null) { + this.batchedArgs.clear(); + } + } + + @Override + public QueryAttributesBindings getQueryAttributesBindings() { + return this.queryAttributesBindings; + } + + @Override + public int getResultFetchSize() { + return this.fetchSize; + } + + @Override + public void setResultFetchSize(int fetchSize) { + this.fetchSize = fetchSize; + } + + public Resultset.Type getResultType() { + return this.resultSetType; + } + + public void setResultType(Resultset.Type resultSetType) { + this.resultSetType = resultSetType; + } + + public int getTimeoutInMillis() { + return this.timeoutInMillis; + } + + public void setTimeoutInMillis(int timeoutInMillis) { + this.timeoutInMillis = timeoutInMillis; + } + + public CancelQueryTask startQueryTimer(Query stmtToCancel, int timeout) { + if (this.session.getPropertySet().getBooleanProperty(PropertyKey.enableQueryTimeouts).getValue() && timeout != 0) { + CancelQueryTaskImpl timeoutTask = new CancelQueryTaskImpl(stmtToCancel); + this.session.getCancelTimer().schedule(timeoutTask, timeout); + return timeoutTask; + } + return null; + } + + public void stopQueryTimer(CancelQueryTask timeoutTask, boolean rethrowCancelReason, boolean checkCancelTimeout) { + if (timeoutTask != null) { + timeoutTask.cancel(); + + if (rethrowCancelReason && timeoutTask.getCaughtWhileCancelling() != null) { + Throwable t = timeoutTask.getCaughtWhileCancelling(); + throw ExceptionFactory.createException(t.getMessage(), t); + } + + this.session.getCancelTimer().purge(); + + if (checkCancelTimeout) { + checkCancelTimeout(); + } + } + } + + public AtomicBoolean getStatementExecuting() { + return this.statementExecuting; + } + + public String getCurrentDatabase() { + return this.currentDb; + } + + public void setCurrentDatabase(String currentDb) { + this.currentDb = currentDb; + } + + public boolean isClearWarningsCalled() { + return this.clearWarningsCalled; + } + + public void setClearWarningsCalled(boolean clearWarningsCalled) { + this.clearWarningsCalled = clearWarningsCalled; + } + + public void statementBegins() { + this.clearWarningsCalled = false; + this.statementExecuting.set(true); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/AbstractQueryBindings.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/AbstractQueryBindings.java new file mode 100644 index 0000000..6da3d89 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/AbstractQueryBindings.java @@ -0,0 +1,1142 @@ +/* + * Copyright (c) 2017, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.ObjectOutputStream; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.sql.Timestamp; +import java.time.Duration; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.OffsetDateTime; +import java.time.OffsetTime; +import java.time.ZoneOffset; +import java.time.ZonedDateTime; +import java.util.Calendar; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; + +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.conf.RuntimeProperty; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.WrongArgumentException; +import com.mysql.cj.protocol.ColumnDefinition; +import com.mysql.cj.protocol.a.NativeConstants.IntegerDataType; +import com.mysql.cj.protocol.a.NativePacketPayload; +import com.mysql.cj.util.StringUtils; +import com.mysql.cj.util.TimeUtil; +import com.mysql.cj.util.Util; + +//TODO should not be protocol-specific +public abstract class AbstractQueryBindings implements QueryBindings { + + protected final static byte[] HEX_DIGITS = new byte[] { (byte) '0', (byte) '1', (byte) '2', (byte) '3', (byte) '4', (byte) '5', (byte) '6', (byte) '7', + (byte) '8', (byte) '9', (byte) 'A', (byte) 'B', (byte) 'C', (byte) 'D', (byte) 'E', (byte) 'F' }; + + protected final static LocalDate DEFAULT_DATE = LocalDate.of(1970, 1, 1); + protected final static LocalTime DEFAULT_TIME = LocalTime.of(0, 0); + + protected Session session; + + /** Bind values for individual fields */ + protected T[] bindValues; + + protected String charEncoding; + + protected int numberOfExecutions = 0; + + protected RuntimeProperty useStreamLengthsInPrepStmts; + protected RuntimeProperty preserveInstants; + protected RuntimeProperty sendFractionalSeconds; + protected RuntimeProperty sendFractionalSecondsForTime; + private RuntimeProperty treatUtilDateAsTimestamp; + + /** Is this query a LOAD DATA query? */ + protected boolean isLoadDataQuery = false; + + protected ColumnDefinition columnDefinition; + + public AbstractQueryBindings(int parameterCount, Session sess) { + this.session = sess; + this.charEncoding = this.session.getPropertySet().getStringProperty(PropertyKey.characterEncoding).getValue(); + this.preserveInstants = this.session.getPropertySet().getBooleanProperty(PropertyKey.preserveInstants); + this.sendFractionalSeconds = this.session.getPropertySet().getBooleanProperty(PropertyKey.sendFractionalSeconds); + this.sendFractionalSecondsForTime = this.session.getPropertySet().getBooleanProperty(PropertyKey.sendFractionalSecondsForTime); + this.treatUtilDateAsTimestamp = this.session.getPropertySet().getBooleanProperty(PropertyKey.treatUtilDateAsTimestamp); + this.useStreamLengthsInPrepStmts = this.session.getPropertySet().getBooleanProperty(PropertyKey.useStreamLengthsInPrepStmts); + + initBindValues(parameterCount); + } + + protected abstract void initBindValues(int parameterCount); + + @Override + public abstract AbstractQueryBindings clone(); + + @Override + public void setColumnDefinition(ColumnDefinition colDef) { + this.columnDefinition = colDef; + } + + @Override + public boolean isLoadDataQuery() { + return this.isLoadDataQuery; + } + + @Override + public void setLoadDataQuery(boolean isLoadDataQuery) { + this.isLoadDataQuery = isLoadDataQuery; + } + + @Override + public T[] getBindValues() { + return this.bindValues; + } + + @Override + public void setBindValues(T[] bindValues) { + this.bindValues = bindValues; + } + + @Override + public boolean clearBindValues() { + boolean hadLongData = false; + + if (this.bindValues != null) { + for (int i = 0; i < this.bindValues.length; i++) { + if ((this.bindValues[i] != null) && this.bindValues[i].isStream()) { + hadLongData = true; + } + this.bindValues[i].reset(); + } + } + + return hadLongData; + } + + public abstract void checkParameterSet(int columnIndex); + + public void checkAllParametersSet() { + for (int i = 0; i < this.bindValues.length; i++) { + checkParameterSet(i); + } + } + + public int getNumberOfExecutions() { + return this.numberOfExecutions; + } + + public void setNumberOfExecutions(int numberOfExecutions) { + this.numberOfExecutions = numberOfExecutions; + } + + public synchronized final void setValue(int paramIndex, byte[] val, MysqlType type) { + this.bindValues[paramIndex].setByteValue(val); + this.bindValues[paramIndex].setMysqlType(type); + } + + public synchronized final void setOrigValue(int paramIndex, byte[] val) { + this.bindValues[paramIndex].setOrigByteValue(val); + } + + @Override + public synchronized byte[] getOrigBytes(int parameterIndex) { + return this.bindValues[parameterIndex].getOrigByteValue(); + } + + public synchronized final void setValue(int paramIndex, String val, MysqlType type) { + byte[] parameterAsBytes = StringUtils.getBytes(val, this.charEncoding); + setValue(paramIndex, parameterAsBytes, type); + } + + /** + * Used to escape binary data with hex for mb charsets + * + * @param buf + * source bytes + * @param packet + * write to this packet + * @param size + * number of bytes to read + */ + public final void hexEscapeBlock(byte[] buf, NativePacketPayload packet, int size) { + for (int i = 0; i < size; i++) { + byte b = buf[i]; + int lowBits = (b & 0xff) / 16; + int highBits = (b & 0xff) % 16; + + packet.writeInteger(IntegerDataType.INT1, HEX_DIGITS[lowBits]); + packet.writeInteger(IntegerDataType.INT1, HEX_DIGITS[highBits]); + } + } + + static Map, MysqlType> DEFAULT_MYSQL_TYPES = new HashMap<>(); + static { + DEFAULT_MYSQL_TYPES.put(String.class, MysqlType.VARCHAR); + DEFAULT_MYSQL_TYPES.put(java.sql.Date.class, MysqlType.DATE); + DEFAULT_MYSQL_TYPES.put(java.sql.Time.class, MysqlType.TIME); + DEFAULT_MYSQL_TYPES.put(java.sql.Timestamp.class, MysqlType.TIMESTAMP); + DEFAULT_MYSQL_TYPES.put(Byte.class, MysqlType.INT); + DEFAULT_MYSQL_TYPES.put(BigDecimal.class, MysqlType.DECIMAL); + DEFAULT_MYSQL_TYPES.put(Short.class, MysqlType.SMALLINT); + DEFAULT_MYSQL_TYPES.put(Integer.class, MysqlType.INT); + DEFAULT_MYSQL_TYPES.put(Long.class, MysqlType.BIGINT); + DEFAULT_MYSQL_TYPES.put(Float.class, MysqlType.FLOAT); // TODO check; was Types.FLOAT but should be Types.REAL to map to SQL FLOAT + DEFAULT_MYSQL_TYPES.put(Double.class, MysqlType.DOUBLE); + DEFAULT_MYSQL_TYPES.put(byte[].class, MysqlType.BINARY); + DEFAULT_MYSQL_TYPES.put(Boolean.class, MysqlType.BOOLEAN); + DEFAULT_MYSQL_TYPES.put(LocalDate.class, MysqlType.DATE); + DEFAULT_MYSQL_TYPES.put(LocalTime.class, MysqlType.TIME); + DEFAULT_MYSQL_TYPES.put(LocalDateTime.class, MysqlType.DATETIME); // default JDBC mapping is TIMESTAMP, see B-4 + DEFAULT_MYSQL_TYPES.put(OffsetTime.class, MysqlType.TIME); // default JDBC mapping is TIME_WITH_TIMEZONE, see B-4 + DEFAULT_MYSQL_TYPES.put(OffsetDateTime.class, MysqlType.TIMESTAMP); // default JDBC mapping is TIMESTAMP_WITH_TIMEZONE, see B-4 + DEFAULT_MYSQL_TYPES.put(ZonedDateTime.class, MysqlType.TIMESTAMP); // no JDBC mapping is defined + DEFAULT_MYSQL_TYPES.put(Duration.class, MysqlType.TIME); + DEFAULT_MYSQL_TYPES.put(java.sql.Blob.class, MysqlType.BLOB); + DEFAULT_MYSQL_TYPES.put(java.sql.Clob.class, MysqlType.TEXT); + DEFAULT_MYSQL_TYPES.put(BigInteger.class, MysqlType.BIGINT); + DEFAULT_MYSQL_TYPES.put(java.util.Date.class, MysqlType.TIMESTAMP); + DEFAULT_MYSQL_TYPES.put(java.util.Calendar.class, MysqlType.TIMESTAMP); + DEFAULT_MYSQL_TYPES.put(InputStream.class, MysqlType.BLOB); + } + + @Override + public void setTimestamp(int parameterIndex, Timestamp x, MysqlType targetMysqlType) { + int fractLen = -1; + if (!this.session.getServerSession().getCapabilities().serverSupportsFracSecs() || !this.sendFractionalSeconds.getValue()) { + fractLen = 0; + } else if (this.columnDefinition != null && parameterIndex <= this.columnDefinition.getFields().length && parameterIndex >= 0) { + fractLen = this.columnDefinition.getFields()[parameterIndex].getDecimals(); + } + + setTimestamp(parameterIndex, x, null, fractLen, targetMysqlType); + } + + @Override + public void setTimestamp(int parameterIndex, Timestamp x, Calendar cal, MysqlType targetMysqlType) { + int fractLen = -1; + if (!this.session.getServerSession().getCapabilities().serverSupportsFracSecs() || !this.sendFractionalSeconds.getValue()) { + fractLen = 0; + } else if (this.columnDefinition != null && parameterIndex <= this.columnDefinition.getFields().length && parameterIndex >= 0 + && this.columnDefinition.getFields()[parameterIndex].getDecimals() > 0) { + fractLen = this.columnDefinition.getFields()[parameterIndex].getDecimals(); + } + + setTimestamp(parameterIndex, x, cal, fractLen, targetMysqlType); + } + + @Override + public void setTimestamp(int parameterIndex, Timestamp x, Calendar targetCalendar, int fractionalLength, MysqlType targetMysqlType) { + if (x == null) { + setNull(parameterIndex); + return; + } + if (!this.session.getServerSession().getCapabilities().serverSupportsFracSecs() || !this.sendFractionalSeconds.getValue()) { + x = TimeUtil.truncateFractionalSeconds(x); + } + + bindTimestamp(parameterIndex, x, targetCalendar, fractionalLength, targetMysqlType); + } + + @Override + public void setObject(int parameterIndex, Object parameterObj) { + if (parameterObj == null) { + setNull(parameterIndex); + return; + } + + MysqlType defaultMysqlType = DEFAULT_MYSQL_TYPES.get(parameterObj.getClass()); + + if (defaultMysqlType == null) { + Optional mysqlType = DEFAULT_MYSQL_TYPES.entrySet().stream().filter(m -> m.getKey().isAssignableFrom(parameterObj.getClass())) + .map(m -> m.getValue()).findFirst(); + if (mysqlType.isPresent()) { + defaultMysqlType = mysqlType.get(); + } + } + + if (defaultMysqlType != null) { + setObject(parameterIndex, parameterObj, defaultMysqlType); + + } else { + setSerializableObject(parameterIndex, parameterObj); // TODO maybe default to error? + } + } + + @Override + public void setObject(int parameterIndex, Object parameterObj, MysqlType targetMysqlType) { + setObject(parameterIndex, parameterObj, targetMysqlType, parameterObj instanceof BigDecimal ? ((BigDecimal) parameterObj).scale() : 0); + } + + /** + * Set the value of a parameter using an object; use the java.lang equivalent objects for integral values. + * + *

+ * The given Java object will be converted to the targetMysqlType before being sent to the database. + * + * @param parameterIndex + * the first parameter is 1... + * @param parameterObj + * the object containing the input parameter value + * @param targetMysqlType + * The MysqlType to be send to the database + * @param scaleOrLength + * For Types.DECIMAL or Types.NUMERIC types + * this is the number of digits after the decimal. For all other + * types this value will be ignored. + */ + public void setObject(int parameterIndex, Object parameterObj, MysqlType targetMysqlType, int scaleOrLength) { + if (parameterObj == null) { + setNull(parameterIndex); + return; + } + /* + * According to Table-B5 in the JDBC Spec + */ + try { + if (parameterObj instanceof LocalDate) { + switch (targetMysqlType) { + case DATE: + setLocalDate(parameterIndex, (LocalDate) parameterObj, targetMysqlType); + break; + case DATETIME: + case TIMESTAMP: + setLocalDateTime(parameterIndex, LocalDateTime.of((LocalDate) parameterObj, DEFAULT_TIME), targetMysqlType); + break; + case YEAR: + setInt(parameterIndex, ((LocalDate) parameterObj).getYear()); + break; + case CHAR: + case VARCHAR: + case TINYTEXT: + case TEXT: + case MEDIUMTEXT: + case LONGTEXT: + setString(parameterIndex, parameterObj.toString()); + break; + default: + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("PreparedStatement.67", new Object[] { parameterObj.getClass().getName(), targetMysqlType.toString() }), + this.session.getExceptionInterceptor()); + } + + } else if (parameterObj instanceof LocalTime) { + switch (targetMysqlType) { + case TIME: + setLocalTime(parameterIndex, (LocalTime) parameterObj, targetMysqlType); + break; + case CHAR: + case VARCHAR: + case TINYTEXT: + case TEXT: + case MEDIUMTEXT: + case LONGTEXT: + setString(parameterIndex, + ((LocalTime) parameterObj).format(this.sendFractionalSeconds.getValue() && ((LocalTime) parameterObj).getNano() > 0 + ? TimeUtil.TIME_FORMATTER_WITH_NANOS_NO_OFFSET + : TimeUtil.TIME_FORMATTER_NO_FRACT_NO_OFFSET)); + break; + default: + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("PreparedStatement.67", new Object[] { parameterObj.getClass().getName(), targetMysqlType.toString() }), + this.session.getExceptionInterceptor()); + } + + } else if (parameterObj instanceof LocalDateTime) { + switch (targetMysqlType) { + case DATE: + case DATETIME: + case TIMESTAMP: + case TIME: + setLocalDateTime(parameterIndex, ((LocalDateTime) parameterObj), targetMysqlType); + break; + case YEAR: + setInt(parameterIndex, ((LocalDateTime) parameterObj).getYear()); + break; + case CHAR: + case VARCHAR: + case TINYTEXT: + case TEXT: + case MEDIUMTEXT: + case LONGTEXT: + setString(parameterIndex, + ((LocalDateTime) parameterObj).format(this.sendFractionalSeconds.getValue() && ((LocalDateTime) parameterObj).getNano() > 0 + ? TimeUtil.DATETIME_FORMATTER_WITH_NANOS_NO_OFFSET + : TimeUtil.DATETIME_FORMATTER_NO_FRACT_NO_OFFSET)); + break; + default: + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("PreparedStatement.67", new Object[] { parameterObj.getClass().getName(), targetMysqlType.toString() }), + this.session.getExceptionInterceptor()); + } + + } else if (parameterObj instanceof OffsetTime) { + switch (targetMysqlType) { + case TIME: + setLocalTime(parameterIndex, + ((OffsetTime) parameterObj) + .withOffsetSameInstant( + ZoneOffset.ofTotalSeconds(this.session.getServerSession().getDefaultTimeZone().getRawOffset() / 1000)) + .toLocalTime(), + targetMysqlType); + break; + case CHAR: + case VARCHAR: + case TINYTEXT: + case TEXT: + case MEDIUMTEXT: + case LONGTEXT: + setString(parameterIndex, + ((OffsetTime) parameterObj).format(this.sendFractionalSeconds.getValue() && ((OffsetTime) parameterObj).getNano() > 0 + ? TimeUtil.TIME_FORMATTER_WITH_NANOS_WITH_OFFSET + : TimeUtil.TIME_FORMATTER_NO_FRACT_WITH_OFFSET)); + break; + default: + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("PreparedStatement.67", new Object[] { parameterObj.getClass().getName(), targetMysqlType.toString() }), + this.session.getExceptionInterceptor()); + } + + } else if (parameterObj instanceof OffsetDateTime) { + switch (targetMysqlType) { + case DATE: + setLocalDate(parameterIndex, ((OffsetDateTime) parameterObj) + .atZoneSameInstant(this.session.getServerSession().getDefaultTimeZone().toZoneId()).toLocalDate(), targetMysqlType); + break; + case DATETIME: + case TIMESTAMP: + java.sql.Timestamp ts = Timestamp.valueOf(((OffsetDateTime) parameterObj) + .atZoneSameInstant(this.session.getServerSession().getDefaultTimeZone().toZoneId()).toLocalDateTime()); + + int fractLen = -1; + if (!this.session.getServerSession().getCapabilities().serverSupportsFracSecs() || !this.sendFractionalSeconds.getValue()) { + fractLen = 0; + } else if (this.columnDefinition != null && parameterIndex <= this.columnDefinition.getFields().length && parameterIndex >= 0 + && this.columnDefinition.getFields()[parameterIndex].getDecimals() > 0) { + fractLen = this.columnDefinition.getFields()[parameterIndex].getDecimals(); + } + + if (fractLen == 0) { + ts = TimeUtil.truncateFractionalSeconds(ts); + } + + bindTimestamp(parameterIndex, ts, null, fractLen, targetMysqlType); + break; + case TIME: + setLocalTime(parameterIndex, ((OffsetDateTime) parameterObj) + .atZoneSameInstant(this.session.getServerSession().getDefaultTimeZone().toZoneId()).toLocalTime(), targetMysqlType); + break; + case YEAR: + setInt(parameterIndex, + ((OffsetDateTime) parameterObj).atZoneSameInstant(this.session.getServerSession().getDefaultTimeZone().toZoneId()).getYear()); + break; + case CHAR: + case VARCHAR: + case TINYTEXT: + case TEXT: + case MEDIUMTEXT: + case LONGTEXT: + setString(parameterIndex, + ((OffsetDateTime) parameterObj).format(this.sendFractionalSeconds.getValue() && ((OffsetDateTime) parameterObj).getNano() > 0 + ? TimeUtil.DATETIME_FORMATTER_WITH_NANOS_WITH_OFFSET + : TimeUtil.DATETIME_FORMATTER_NO_FRACT_WITH_OFFSET)); + break; + default: + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("PreparedStatement.67", new Object[] { parameterObj.getClass().getName(), targetMysqlType.toString() }), + this.session.getExceptionInterceptor()); + } + + } else if (parameterObj instanceof ZonedDateTime) { + switch (targetMysqlType) { + case DATE: + setLocalDate(parameterIndex, ((ZonedDateTime) parameterObj) + .withZoneSameInstant(this.session.getServerSession().getDefaultTimeZone().toZoneId()).toLocalDate(), targetMysqlType); + break; + case DATETIME: + case TIMESTAMP: + java.sql.Timestamp ts = Timestamp.valueOf(((ZonedDateTime) parameterObj) + .withZoneSameInstant(this.session.getServerSession().getDefaultTimeZone().toZoneId()).toLocalDateTime()); + + int fractLen = -1; + if (!this.session.getServerSession().getCapabilities().serverSupportsFracSecs() || !this.sendFractionalSeconds.getValue()) { + fractLen = 0; + } else if (this.columnDefinition != null && parameterIndex <= this.columnDefinition.getFields().length && parameterIndex >= 0 + && this.columnDefinition.getFields()[parameterIndex].getDecimals() > 0) { + fractLen = this.columnDefinition.getFields()[parameterIndex].getDecimals(); + } + + if (fractLen == 0) { + ts = TimeUtil.truncateFractionalSeconds(ts); + } + + bindTimestamp(parameterIndex, ts, null, fractLen, targetMysqlType); + break; + case TIME: + setLocalTime(parameterIndex, ((ZonedDateTime) parameterObj) + .withZoneSameInstant(this.session.getServerSession().getDefaultTimeZone().toZoneId()).toLocalTime(), targetMysqlType); + break; + case YEAR: + setInt(parameterIndex, + ((ZonedDateTime) parameterObj).withZoneSameInstant(this.session.getServerSession().getDefaultTimeZone().toZoneId()).getYear()); + break; + case CHAR: + case VARCHAR: + case TINYTEXT: + case TEXT: + case MEDIUMTEXT: + case LONGTEXT: + setString(parameterIndex, + ((ZonedDateTime) parameterObj).format(this.sendFractionalSeconds.getValue() && ((ZonedDateTime) parameterObj).getNano() > 0 + ? TimeUtil.DATETIME_FORMATTER_WITH_NANOS_WITH_OFFSET + : TimeUtil.DATETIME_FORMATTER_NO_FRACT_WITH_OFFSET)); + break; + default: + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("PreparedStatement.67", new Object[] { parameterObj.getClass().getName(), targetMysqlType.toString() }), + this.session.getExceptionInterceptor()); + } + + } else if (parameterObj instanceof Duration) { + switch (targetMysqlType) { + case TIME: + setDuration(parameterIndex, (Duration) parameterObj, targetMysqlType); + break; + case CHAR: + case VARCHAR: + case TINYTEXT: + case TEXT: + case MEDIUMTEXT: + case LONGTEXT: + setString(parameterIndex, TimeUtil.getDurationString((Duration) parameterObj)); + break; + default: + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("PreparedStatement.67", new Object[] { parameterObj.getClass().getName(), targetMysqlType.toString() }), + this.session.getExceptionInterceptor()); + } + + } else if (parameterObj instanceof java.sql.Date) { + switch (targetMysqlType) { + case DATE: + setDate(parameterIndex, (java.sql.Date) parameterObj); + break; + case DATETIME: + case TIMESTAMP: + setTimestamp(parameterIndex, new java.sql.Timestamp(((java.util.Date) parameterObj).getTime()), targetMysqlType); + break; + case YEAR: + Calendar cal = Calendar.getInstance(); + cal.setTime((java.util.Date) parameterObj); + setInt(parameterIndex, cal.get(Calendar.YEAR)); + break; + case CHAR: + case VARCHAR: + case TINYTEXT: + case TEXT: + case MEDIUMTEXT: + case LONGTEXT: + setString(parameterIndex, parameterObj.toString()); + break; + default: + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("PreparedStatement.67", new Object[] { parameterObj.getClass().getName(), targetMysqlType.toString() }), + this.session.getExceptionInterceptor()); + } + + } else if (parameterObj instanceof java.sql.Timestamp) { + switch (targetMysqlType) { + case DATE: + setDate(parameterIndex, new java.sql.Date(((java.util.Date) parameterObj).getTime())); + break; + case DATETIME: + case TIMESTAMP: + setTimestamp(parameterIndex, (java.sql.Timestamp) parameterObj, targetMysqlType); + break; + case YEAR: + Calendar cal = Calendar.getInstance(); + cal.setTime((java.util.Date) parameterObj); + setInt(parameterIndex, cal.get(Calendar.YEAR)); + break; + case TIME: + setLocalTime(parameterIndex, ((java.sql.Timestamp) parameterObj).toLocalDateTime().toLocalTime(), targetMysqlType); + break; + case CHAR: + case VARCHAR: + case TINYTEXT: + case TEXT: + case MEDIUMTEXT: + case LONGTEXT: + String val = parameterObj.toString(); + int dotPos; + if ((((java.sql.Timestamp) parameterObj).getNanos() == 0 || !this.sendFractionalSeconds.getValue()) + && (dotPos = val.indexOf(".")) > 0) { + val = val.substring(0, dotPos); + } + setString(parameterIndex, val); + break; + default: + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("PreparedStatement.67", new Object[] { parameterObj.getClass().getName(), targetMysqlType.toString() }), + this.session.getExceptionInterceptor()); + } + + } else if (parameterObj instanceof java.sql.Time) { + switch (targetMysqlType) { + case DATE: + setDate(parameterIndex, new java.sql.Date(((java.util.Date) parameterObj).getTime())); + break; + case DATETIME: + case TIMESTAMP: + java.sql.Timestamp ts = new java.sql.Timestamp(((java.sql.Time) parameterObj).getTime()); + + int fractLen = -1; + if (!this.session.getServerSession().getCapabilities().serverSupportsFracSecs() || !this.sendFractionalSecondsForTime.getValue() + || !this.sendFractionalSeconds.getValue()) { + fractLen = 0; + } else if (this.columnDefinition != null && parameterIndex <= this.columnDefinition.getFields().length && parameterIndex >= 0 + && this.columnDefinition.getFields()[parameterIndex].getDecimals() > 0) { + fractLen = this.columnDefinition.getFields()[parameterIndex].getDecimals(); + } + + if (fractLen == 0) { + ts = TimeUtil.truncateFractionalSeconds(ts); + } + + bindTimestamp(parameterIndex, ts, null, fractLen, MysqlType.DATETIME); // Override TIMESTAMP to avoid conversion to the server time zone + + break; + case YEAR: + Calendar cal = Calendar.getInstance(); + cal.setTime((java.util.Date) parameterObj); + setInt(parameterIndex, cal.get(Calendar.YEAR)); + break; + case TIME: + setTime(parameterIndex, (java.sql.Time) parameterObj); + break; + case CHAR: + case VARCHAR: + case TINYTEXT: + case TEXT: + case MEDIUMTEXT: + case LONGTEXT: + setString( + parameterIndex, TimeUtil + .getSimpleDateFormat(this.session.getServerSession().getCapabilities().serverSupportsFracSecs() + && this.sendFractionalSeconds.getValue() && this.sendFractionalSecondsForTime.getValue() + && TimeUtil.hasFractionalSeconds((java.sql.Time) parameterObj) ? "HH:mm:ss.SSS" : "HH:mm:ss", null) + .format(parameterObj)); + break; + default: + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("PreparedStatement.67", new Object[] { parameterObj.getClass().getName(), targetMysqlType.toString() }), + this.session.getExceptionInterceptor()); + } + + } else if (parameterObj instanceof java.util.Date) { + if (!this.treatUtilDateAsTimestamp.getValue()) { // TODO is it needed at all? + setSerializableObject(parameterIndex, parameterObj); + return; + } + switch (targetMysqlType) { + case DATE: + setDate(parameterIndex, new java.sql.Date(((java.util.Date) parameterObj).getTime())); + break; + case DATETIME: + case TIMESTAMP: + setTimestamp(parameterIndex, new java.sql.Timestamp(((java.util.Date) parameterObj).getTime()), targetMysqlType); + break; + case YEAR: + Calendar cal = Calendar.getInstance(); + cal.setTime(((java.util.Date) parameterObj)); + setInt(parameterIndex, cal.get(Calendar.YEAR)); + break; + case TIME: + LocalTime lt = ((java.util.Date) parameterObj).toInstant().atZone(this.session.getServerSession().getDefaultTimeZone().toZoneId()) + .toLocalTime(); + setLocalTime(parameterIndex, lt, targetMysqlType); + break; + case CHAR: + case VARCHAR: + case TINYTEXT: + case TEXT: + case MEDIUMTEXT: + case LONGTEXT: + setString(parameterIndex, TimeUtil.getSimpleDateFormat( + this.session.getServerSession().getCapabilities().serverSupportsFracSecs() && this.sendFractionalSeconds.getValue() + && ((java.util.Date) parameterObj).toInstant().getNano() > 0 ? "yyyy-MM-dd HH:mm:ss.SSS" : "yyyy-MM-dd HH:mm:ss", + null).format(parameterObj)); + break; + default: + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("PreparedStatement.67", new Object[] { parameterObj.getClass().getName(), targetMysqlType.toString() }), + this.session.getExceptionInterceptor()); + } + + } else if (parameterObj instanceof java.util.Calendar) { + switch (targetMysqlType) { + case DATE: + setDate(parameterIndex, new java.sql.Date(((java.util.Calendar) parameterObj).getTimeInMillis())); + break; + case DATETIME: + case TIMESTAMP: + setTimestamp(parameterIndex, new java.sql.Timestamp(((java.util.Calendar) parameterObj).getTimeInMillis()), targetMysqlType); + break; + case YEAR: + setInt(parameterIndex, ((java.util.Calendar) parameterObj).get(Calendar.YEAR)); + break; + case TIME: + LocalTime lt = ((java.util.Calendar) parameterObj).toInstant().atZone(this.session.getServerSession().getDefaultTimeZone().toZoneId()) + .toLocalTime(); + setLocalTime(parameterIndex, lt, targetMysqlType); + break; + case CHAR: + case VARCHAR: + case TINYTEXT: + case TEXT: + case MEDIUMTEXT: + case LONGTEXT: + ZonedDateTime zdt = ZonedDateTime + .ofInstant(((java.util.Calendar) parameterObj).toInstant(), ((java.util.Calendar) parameterObj).getTimeZone().toZoneId()) + .withZoneSameInstant(this.session.getServerSession().getDefaultTimeZone().toZoneId()); + setString(parameterIndex, + zdt.format(zdt.getNano() > 0 && this.session.getServerSession().getCapabilities().serverSupportsFracSecs() + && this.sendFractionalSeconds.getValue() ? TimeUtil.DATETIME_FORMATTER_WITH_MILLIS_NO_OFFSET + : TimeUtil.DATETIME_FORMATTER_NO_FRACT_NO_OFFSET)); + break; + default: + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("PreparedStatement.67", new Object[] { parameterObj.getClass().getName(), targetMysqlType.toString() }), + this.session.getExceptionInterceptor()); + } + + } else if (parameterObj instanceof String) { + switch (targetMysqlType) { + case BOOLEAN: + if ("true".equalsIgnoreCase((String) parameterObj) || "Y".equalsIgnoreCase((String) parameterObj)) { + setBoolean(parameterIndex, true); + } else if ("false".equalsIgnoreCase((String) parameterObj) || "N".equalsIgnoreCase((String) parameterObj)) { + setBoolean(parameterIndex, false); + } else if (((String) parameterObj).matches("-?\\d+\\.?\\d*")) { + setBoolean(parameterIndex, !((String) parameterObj).matches("-?[0]+[.]*[0]*")); + } else { + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("PreparedStatement.66", new Object[] { parameterObj }), this.session.getExceptionInterceptor()); + } + break; + case BIT: + if ("1".equals(parameterObj) || "0".equals(parameterObj)) { + setInt(parameterIndex, Integer.valueOf((String) parameterObj).intValue()); + } else { + boolean parameterAsBoolean = "true".equalsIgnoreCase((String) parameterObj); + setInt(parameterIndex, parameterAsBoolean ? 1 : 0); + } + break; + + case TINYINT: + case TINYINT_UNSIGNED: + case SMALLINT: + case SMALLINT_UNSIGNED: + case MEDIUMINT: + case MEDIUMINT_UNSIGNED: + case INT: + case INT_UNSIGNED: + //case YEAR: + setInt(parameterIndex, Integer.valueOf((String) parameterObj).intValue()); + break; + case BIGINT: + setLong(parameterIndex, Long.valueOf((String) parameterObj).longValue()); + break; + case BIGINT_UNSIGNED: + setLong(parameterIndex, new BigInteger((String) parameterObj).longValue()); + break; + case FLOAT: + case FLOAT_UNSIGNED: + setFloat(parameterIndex, Float.valueOf((String) parameterObj).floatValue()); + break; + case DOUBLE: + case DOUBLE_UNSIGNED: + setDouble(parameterIndex, Double.valueOf((String) parameterObj).doubleValue()); + break; + case DECIMAL: + case DECIMAL_UNSIGNED: + BigDecimal parameterAsNum = new BigDecimal((String) parameterObj); + BigDecimal scaledBigDecimal = null; + + try { + scaledBigDecimal = parameterAsNum.setScale(scaleOrLength); + } catch (ArithmeticException ex) { + try { + scaledBigDecimal = parameterAsNum.setScale(scaleOrLength, BigDecimal.ROUND_HALF_UP); + } catch (ArithmeticException arEx) { + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("PreparedStatement.65", new Object[] { scaleOrLength, parameterAsNum }), + this.session.getExceptionInterceptor()); + } + } + setBigDecimal(parameterIndex, scaledBigDecimal); + break; + + case CHAR: + case ENUM: + case SET: + case VARCHAR: + case TINYTEXT: + case TEXT: + case MEDIUMTEXT: + case LONGTEXT: + case JSON: + setString(parameterIndex, parameterObj.toString()); + break; + case BINARY: + case GEOMETRY: + case VARBINARY: + case TINYBLOB: + case BLOB: + case MEDIUMBLOB: + case LONGBLOB: + setBytes(parameterIndex, StringUtils.getBytes(parameterObj.toString(), this.charEncoding)); + break; + case DATE: + case DATETIME: + case TIMESTAMP: + case TIME: + case YEAR: + setObject(parameterIndex, TimeUtil.parseToDateTimeObject((String) parameterObj, targetMysqlType), targetMysqlType); + break; + case UNKNOWN: + setSerializableObject(parameterIndex, parameterObj); + break; + default: + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("PreparedStatement.67", new Object[] { parameterObj.getClass().getName(), targetMysqlType.toString() }), + this.session.getExceptionInterceptor()); + } + + } else if (parameterObj instanceof InputStream) { + setBinaryStream(parameterIndex, (InputStream) parameterObj, -1); + + } else if (parameterObj instanceof Boolean) { + switch (targetMysqlType) { + case BOOLEAN: + setBoolean(parameterIndex, ((Boolean) parameterObj).booleanValue()); + break; + case BIT: + case TINYINT: + case TINYINT_UNSIGNED: + case SMALLINT: + case SMALLINT_UNSIGNED: + case MEDIUMINT: + case MEDIUMINT_UNSIGNED: + case INT: + case INT_UNSIGNED: + case YEAR: + setInt(parameterIndex, ((Boolean) parameterObj).booleanValue() ? 1 : 0); + break; + case BIGINT: + case BIGINT_UNSIGNED: + setLong(parameterIndex, ((Boolean) parameterObj).booleanValue() ? 1L : 0L); + break; + case FLOAT: + case FLOAT_UNSIGNED: + setFloat(parameterIndex, ((Boolean) parameterObj).booleanValue() ? 1f : 0f); + break; + case DOUBLE: + case DOUBLE_UNSIGNED: + setDouble(parameterIndex, ((Boolean) parameterObj).booleanValue() ? 1d : 0d); + break; + case DECIMAL: + case DECIMAL_UNSIGNED: + setBigDecimal(parameterIndex, new java.math.BigDecimal(((Boolean) parameterObj).booleanValue() ? 1d : 0d)); + break; + case CHAR: + case VARCHAR: + case TINYTEXT: + case TEXT: + case MEDIUMTEXT: + case LONGTEXT: + setString(parameterIndex, parameterObj.toString()); + break; + default: + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("PreparedStatement.67", new Object[] { parameterObj.getClass().getName(), targetMysqlType.toString() }), + this.session.getExceptionInterceptor()); + } + + } else if (parameterObj instanceof Number) { + Number parameterAsNum = (Number) parameterObj; + switch (targetMysqlType) { + case BOOLEAN: + setBoolean(parameterIndex, parameterAsNum.intValue() != 0); + break; + case BIT: + case TINYINT: + case TINYINT_UNSIGNED: + case SMALLINT: + case SMALLINT_UNSIGNED: + case MEDIUMINT: + case MEDIUMINT_UNSIGNED: + case INT: + case INT_UNSIGNED: + case YEAR: + setInt(parameterIndex, parameterAsNum.intValue()); + break; + case BIGINT: + case BIGINT_UNSIGNED: + setLong(parameterIndex, parameterAsNum.longValue()); + break; + case FLOAT: + case FLOAT_UNSIGNED: + setFloat(parameterIndex, parameterAsNum.floatValue()); + break; + case DOUBLE: + case DOUBLE_UNSIGNED: + setDouble(parameterIndex, parameterAsNum.doubleValue()); + break; + case DECIMAL: + case DECIMAL_UNSIGNED: + if (parameterAsNum instanceof BigDecimal) { + BigDecimal scaledBigDecimal = null; + + try { + scaledBigDecimal = ((BigDecimal) parameterAsNum).setScale(scaleOrLength); + } catch (ArithmeticException ex) { + try { + scaledBigDecimal = ((BigDecimal) parameterAsNum).setScale(scaleOrLength, BigDecimal.ROUND_HALF_UP); + } catch (ArithmeticException arEx) { + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("PreparedStatement.65", new Object[] { scaleOrLength, parameterAsNum }), + this.session.getExceptionInterceptor()); + } + } + + setBigDecimal(parameterIndex, scaledBigDecimal); + } else if (parameterAsNum instanceof java.math.BigInteger) { + setBigDecimal(parameterIndex, new BigDecimal((java.math.BigInteger) parameterAsNum, scaleOrLength)); + } else { + setBigDecimal(parameterIndex, new BigDecimal(parameterAsNum.doubleValue())); + } + + break; + case CHAR: + case ENUM: + case SET: + case VARCHAR: + case TINYTEXT: + case TEXT: + case MEDIUMTEXT: + case LONGTEXT: + case JSON: + if (parameterObj instanceof BigDecimal) { + setString(parameterIndex, (StringUtils.fixDecimalExponent(((BigDecimal) parameterObj).toPlainString()))); + } else { + setString(parameterIndex, parameterObj.toString()); + } + break; + + case BINARY: + case GEOMETRY: + case VARBINARY: + case TINYBLOB: + case BLOB: + case MEDIUMBLOB: + case LONGBLOB: + setBytes(parameterIndex, StringUtils.getBytes(parameterObj.toString(), this.charEncoding)); + break; + default: + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("PreparedStatement.67", new Object[] { parameterObj.getClass().getName(), targetMysqlType.toString() }), + this.session.getExceptionInterceptor()); + } + + } else { + + switch (targetMysqlType) { + case BOOLEAN: + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("PreparedStatement.66", new Object[] { parameterObj.getClass().getName() }), + this.session.getExceptionInterceptor()); + case CHAR: + case ENUM: + case SET: + case VARCHAR: + case TINYTEXT: + case TEXT: + case MEDIUMTEXT: + case LONGTEXT: + case JSON: + if (parameterObj instanceof BigDecimal) { + setString(parameterIndex, (StringUtils.fixDecimalExponent(((BigDecimal) parameterObj).toPlainString()))); + } else if (parameterObj instanceof java.sql.Clob) { + setClob(parameterIndex, (java.sql.Clob) parameterObj); + } else { + setString(parameterIndex, parameterObj.toString()); + } + break; + + case BINARY: + case GEOMETRY: + case VARBINARY: + case TINYBLOB: + case BLOB: + case MEDIUMBLOB: + case LONGBLOB: + if (parameterObj instanceof byte[]) { + setBytes(parameterIndex, (byte[]) parameterObj); + } else if (parameterObj instanceof java.sql.Blob) { + setBlob(parameterIndex, (java.sql.Blob) parameterObj); + } else { + setBytes(parameterIndex, StringUtils.getBytes(parameterObj.toString(), this.charEncoding)); + } + + break; + case UNKNOWN: + setSerializableObject(parameterIndex, parameterObj); + break; + + default: + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("PreparedStatement.67", new Object[] { parameterObj.getClass().getName(), targetMysqlType.toString() }), + this.session.getExceptionInterceptor()); + } + } + } catch (Exception ex) { + throw ExceptionFactory.createException( + Messages.getString("PreparedStatement.17") + parameterObj.getClass().toString() + Messages.getString("PreparedStatement.18") + + ex.getClass().getName() + Messages.getString("PreparedStatement.19") + ex.getMessage(), + ex, this.session.getExceptionInterceptor()); + } + } + + /** + * Sets the value for the placeholder as a serialized Java object (used by various forms of setObject() + * + * @param parameterIndex + * parameter index + * @param parameterObj + * value + */ + protected final void setSerializableObject(int parameterIndex, Object parameterObj) { + try { + ByteArrayOutputStream bytesOut = new ByteArrayOutputStream(); + ObjectOutputStream objectOut = new ObjectOutputStream(bytesOut); + objectOut.writeObject(parameterObj); + objectOut.flush(); + objectOut.close(); + bytesOut.flush(); + bytesOut.close(); + + byte[] buf = bytesOut.toByteArray(); + ByteArrayInputStream bytesIn = new ByteArrayInputStream(buf); + setBinaryStream(parameterIndex, bytesIn, buf.length); + this.bindValues[parameterIndex].setMysqlType(MysqlType.BINARY); + } catch (Exception ex) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("PreparedStatement.54") + ex.getClass().getName(), ex, + this.session.getExceptionInterceptor()); + } + } + + @Override + public boolean isNull(int parameterIndex) { + return this.bindValues[parameterIndex].isNull(); + } + + public byte[] getBytesRepresentation(int parameterIndex) { + if (this.bindValues[parameterIndex].isStream()) { + return streamToBytes(parameterIndex, this.session.getPropertySet().getBooleanProperty(PropertyKey.useStreamLengthsInPrepStmts).getValue()); + } + + byte[] parameterVal = this.bindValues[parameterIndex].getByteValue(); + + if (parameterVal == null) { + return null; + } + + return StringUtils.unquoteBytes(parameterVal); + } + + private byte[] streamConvertBuf = null; + + private final byte[] streamToBytes(int parameterIndex, boolean useLength) { + InputStream in = this.bindValues[parameterIndex].getStreamValue(); + in.mark(Integer.MAX_VALUE); // we may need to read this same stream several times, so we need to reset it at the end. + try { + if (this.streamConvertBuf == null) { + this.streamConvertBuf = new byte[4096]; + } + if (this.bindValues[parameterIndex].getStreamLength() == -1) { + useLength = false; + } + + ByteArrayOutputStream bytesOut = new ByteArrayOutputStream(); + + int bc = useLength ? Util.readBlock(in, this.streamConvertBuf, (int) this.bindValues[parameterIndex].getStreamLength(), null) + : Util.readBlock(in, this.streamConvertBuf, null); + + int lengthLeftToRead = (int) this.bindValues[parameterIndex].getStreamLength() - bc; + + while (bc > 0) { + bytesOut.write(this.streamConvertBuf, 0, bc); + + if (useLength) { + bc = Util.readBlock(in, this.streamConvertBuf, lengthLeftToRead, null); + + if (bc > 0) { + lengthLeftToRead -= bc; + } + } else { + bc = Util.readBlock(in, this.streamConvertBuf, null); + } + } + + return bytesOut.toByteArray(); + } finally { + try { + in.reset(); + } catch (IOException e) { + } + if (this.session.getPropertySet().getBooleanProperty(PropertyKey.autoClosePStmtStreams).getValue()) { + try { + in.close(); + } catch (IOException ioEx) { + } + + in = null; + } + } + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/CancelQueryTaskImpl.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/CancelQueryTaskImpl.java new file mode 100644 index 0000000..58cf773 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/CancelQueryTaskImpl.java @@ -0,0 +1,139 @@ +/* + * Copyright (c) 2017, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.util.TimerTask; + +import com.mysql.cj.Query.CancelStatus; +import com.mysql.cj.conf.HostInfo; +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.exceptions.OperationCancelledException; +import com.mysql.cj.protocol.a.NativeMessageBuilder; + +//TODO should not be protocol-specific + +/** + * Thread used to implement query timeouts...Eventually we could be more + * efficient and have one thread with timers, but this is a straightforward + * and simple way to implement a feature that isn't used all that often. + */ +public class CancelQueryTaskImpl extends TimerTask implements CancelQueryTask { + + Query queryToCancel; + Throwable caughtWhileCancelling = null; + boolean queryTimeoutKillsConnection = false; + + public CancelQueryTaskImpl(Query cancellee) { + this.queryToCancel = cancellee; + NativeSession session = (NativeSession) cancellee.getSession(); + this.queryTimeoutKillsConnection = session.getPropertySet().getBooleanProperty(PropertyKey.queryTimeoutKillsConnection).getValue(); + } + + @Override + public boolean cancel() { + boolean res = super.cancel(); + this.queryToCancel = null; + return res; + } + + @Override + public void run() { + + Thread cancelThread = new Thread() { + + @Override + public void run() { + Query localQueryToCancel = CancelQueryTaskImpl.this.queryToCancel; + if (localQueryToCancel == null) { + return; + } + NativeSession session = (NativeSession) localQueryToCancel.getSession(); + if (session == null) { + return; + } + + try { + if (CancelQueryTaskImpl.this.queryTimeoutKillsConnection) { + localQueryToCancel.setCancelStatus(CancelStatus.CANCELED_BY_TIMEOUT); + session.invokeCleanupListeners(new OperationCancelledException(Messages.getString("Statement.ConnectionKilledDueToTimeout"))); + } else { + synchronized (localQueryToCancel.getCancelTimeoutMutex()) { + long origConnId = session.getThreadId(); + HostInfo hostInfo = session.getHostInfo(); + String database = hostInfo.getDatabase(); + String user = hostInfo.getUser(); + String password = hostInfo.getPassword(); + + NativeSession newSession = new NativeSession(hostInfo, session.getPropertySet()); + newSession.connect(hostInfo, user, password, database, 30000, new TransactionEventHandler() { + @Override + public void transactionCompleted() { + } + + public void transactionBegun() { + } + }); + newSession.sendCommand(new NativeMessageBuilder(newSession.getServerSession().supportsQueryAttributes()) + .buildComQuery(newSession.getSharedSendPacket(), "KILL QUERY " + origConnId), false, 0); + + localQueryToCancel.setCancelStatus(CancelStatus.CANCELED_BY_TIMEOUT); + } + } + // } catch (NullPointerException npe) { + // Case when connection closed while starting to cancel. + // We can't easily synchronise this, because then one thread can't cancel() a running query. + // Ignore, we shouldn't re-throw this, because the connection's already closed, so the statement has been timed out. + } catch (Throwable t) { + CancelQueryTaskImpl.this.caughtWhileCancelling = t; + } finally { + setQueryToCancel(null); + } + } + }; + + cancelThread.start(); + } + + public Throwable getCaughtWhileCancelling() { + return this.caughtWhileCancelling; + } + + public void setCaughtWhileCancelling(Throwable caughtWhileCancelling) { + this.caughtWhileCancelling = caughtWhileCancelling; + } + + public Query getQueryToCancel() { + return this.queryToCancel; + } + + public void setQueryToCancel(Query queryToCancel) { + this.queryToCancel = queryToCancel; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/ClientPreparedQuery.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/ClientPreparedQuery.java new file mode 100644 index 0000000..6f2a719 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/ClientPreparedQuery.java @@ -0,0 +1,106 @@ +/* + * Copyright (c) 2017, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +//TODO should not be protocol-specific + +public class ClientPreparedQuery extends AbstractPreparedQuery { + + public ClientPreparedQuery(NativeSession sess) { + super(sess); + } + + /** + * Computes the maximum parameter set size, and entire batch size given + * the number of arguments in the batch. + */ + @Override + protected long[] computeMaxParameterSetSizeAndBatchSize(int numBatchedArgs) { + long sizeOfEntireBatch = 1 /* com_query */; + long maxSizeOfParameterSet = 0; + + if (this.session.getServerSession().supportsQueryAttributes()) { + sizeOfEntireBatch += 9 /* parameter_count */ + 1 /* parameter_set_count */; + sizeOfEntireBatch += (this.queryAttributesBindings.getCount() + 7) / 8 /* null_bitmap */ + 1 /* new_params_bind_flag */; + for (int i = 0; i < this.queryAttributesBindings.getCount(); i++) { + QueryAttributesBindValue queryAttribute = this.queryAttributesBindings.getAttributeValue(i); + sizeOfEntireBatch += 2 /* parameter_type */ + queryAttribute.getName().length() /* parameter_name */ + queryAttribute.getBoundLength(); + } + } + + for (int i = 0; i < numBatchedArgs; i++) { + ClientPreparedQueryBindings qBindings = (ClientPreparedQueryBindings) this.batchedArgs.get(i); + + BindValue[] bindValues = qBindings.getBindValues(); + + long sizeOfParameterSet = 0; + + for (int j = 0; j < bindValues.length; j++) { + if (!bindValues[j].isNull()) { + + if (bindValues[j].isStream()) { + long streamLength = bindValues[j].getStreamLength(); + + if (streamLength != -1) { + sizeOfParameterSet += streamLength * 2; // for safety in escaping + } else { + int paramLength = qBindings.getBindValues()[j].getByteValue().length; + sizeOfParameterSet += paramLength; + } + } else { + sizeOfParameterSet += qBindings.getBindValues()[j].getByteValue().length; + } + } else { + sizeOfParameterSet += 4; // for NULL literal in SQL + } + } + + // + // Account for static part of values clause + // This is a little naive, because the ?s will be replaced but it gives us some padding, and is less housekeeping to ignore them. We're looking + // for a "fuzzy" value here anyway + // + + if (this.parseInfo.getValuesClause() != null) { + sizeOfParameterSet += this.parseInfo.getValuesClause().length() + 1; + } else { + sizeOfParameterSet += this.originalSql.length() + 1; + } + + sizeOfEntireBatch += sizeOfParameterSet; + + if (sizeOfParameterSet > maxSizeOfParameterSet) { + maxSizeOfParameterSet = sizeOfParameterSet; + } + } + + return new long[] { maxSizeOfParameterSet, sizeOfEntireBatch }; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/ClientPreparedQueryBindValue.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/ClientPreparedQueryBindValue.java new file mode 100644 index 0000000..096401c --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/ClientPreparedQueryBindValue.java @@ -0,0 +1,161 @@ +/* + * Copyright (c) 2017, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.io.InputStream; + +public class ClientPreparedQueryBindValue implements BindValue { + + /** NULL indicator */ + protected boolean isNull; + + protected boolean isStream = false; + + protected MysqlType parameterType = MysqlType.NULL; + + /** The value to store */ + public Object value; + + public Object origValue; + + protected long streamLength; + + /** has this parameter been set? */ + protected boolean isSet = false; + + public ClientPreparedQueryBindValue() { + } + + @Override + public ClientPreparedQueryBindValue clone() { + return new ClientPreparedQueryBindValue(this); + } + + protected ClientPreparedQueryBindValue(ClientPreparedQueryBindValue copyMe) { + this.isNull = copyMe.isNull; + this.isStream = copyMe.isStream; + this.parameterType = copyMe.parameterType; + if (copyMe.value != null && copyMe.value instanceof byte[]) { + this.value = new byte[((byte[]) copyMe.value).length]; + System.arraycopy(copyMe.value, 0, this.value, 0, ((byte[]) copyMe.value).length); + } else { + this.value = copyMe.value; + } + this.streamLength = copyMe.streamLength; + this.isSet = copyMe.isSet; + } + + public void reset() { + this.isNull = false; + this.isStream = false; + this.parameterType = MysqlType.NULL; + this.value = null; + this.origValue = null; + this.streamLength = 0; + this.isSet = false; + } + + @Override + public boolean isNull() { + return this.isNull; + } + + public void setNull(boolean isNull) { + this.isNull = isNull; + if (isNull) { + this.parameterType = MysqlType.NULL; + } + this.isSet = true; + } + + public boolean isStream() { + return this.isStream; + } + + public void setIsStream(boolean isStream) { + this.isStream = isStream; + } + + @Override + public MysqlType getMysqlType() { + return this.parameterType; + } + + @Override + public void setMysqlType(MysqlType type) { + this.parameterType = type; + } + + public byte[] getByteValue() { + if (this.value instanceof byte[]) { + return (byte[]) this.value; + } + return null; + } + + public void setByteValue(byte[] parameterValue) { + this.isNull = false; + this.isStream = false; + this.value = parameterValue; + this.streamLength = 0; + this.isSet = true; + } + + @Override + public void setOrigByteValue(byte[] origParamValue) { + this.origValue = origParamValue; + } + + @Override + public byte[] getOrigByteValue() { + return (byte[]) this.origValue; + } + + public InputStream getStreamValue() { + if (this.value instanceof InputStream) { + return (InputStream) this.value; + } + return null; + } + + public void setStreamValue(InputStream parameterStream, long streamLength) { + this.value = parameterStream; + this.streamLength = streamLength; + this.isSet = true; + } + + public long getStreamLength() { + return this.streamLength; + } + + public boolean isSet() { + return this.isSet; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/ClientPreparedQueryBindings.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/ClientPreparedQueryBindings.java new file mode 100644 index 0000000..d4cd710 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/ClientPreparedQueryBindings.java @@ -0,0 +1,922 @@ +/* + * Copyright (c) 2017, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.Reader; +import java.io.UnsupportedEncodingException; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.nio.ByteBuffer; +import java.nio.CharBuffer; +import java.nio.charset.Charset; +import java.nio.charset.CharsetEncoder; +import java.sql.Blob; +import java.sql.Clob; +import java.sql.Date; +import java.sql.NClob; +import java.sql.Time; +import java.sql.Timestamp; +import java.text.SimpleDateFormat; +import java.time.Duration; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.format.DateTimeFormatter; +import java.time.format.DateTimeFormatterBuilder; +import java.time.temporal.ChronoField; +import java.util.Calendar; + +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.MysqlErrorNumbers; +import com.mysql.cj.exceptions.WrongArgumentException; +import com.mysql.cj.util.StringUtils; +import com.mysql.cj.util.TimeUtil; +import com.mysql.cj.util.Util; + +public class ClientPreparedQueryBindings extends AbstractQueryBindings { + + /** Charset encoder used to escape if needed, such as Yen sign in SJIS */ + private CharsetEncoder charsetEncoder; + + private SimpleDateFormat ddf; + + private SimpleDateFormat tdf; + + private SimpleDateFormat tsdf = null; + + public ClientPreparedQueryBindings(int parameterCount, Session sess) { + super(parameterCount, sess); + if (((NativeSession) this.session).getServerSession().getCharsetSettings().getRequiresEscapingEncoder()) { + this.charsetEncoder = Charset.forName(this.charEncoding).newEncoder(); + } + } + + @Override + protected void initBindValues(int parameterCount) { + this.bindValues = new ClientPreparedQueryBindValue[parameterCount]; + for (int i = 0; i < parameterCount; i++) { + this.bindValues[i] = new ClientPreparedQueryBindValue(); + } + } + + @Override + public ClientPreparedQueryBindings clone() { + ClientPreparedQueryBindings newBindings = new ClientPreparedQueryBindings(this.bindValues.length, this.session); + ClientPreparedQueryBindValue[] bvs = new ClientPreparedQueryBindValue[this.bindValues.length]; + for (int i = 0; i < this.bindValues.length; i++) { + bvs[i] = this.bindValues[i].clone(); + } + newBindings.setBindValues(bvs); + newBindings.isLoadDataQuery = this.isLoadDataQuery; + return newBindings; + } + + @Override + public void checkParameterSet(int columnIndex) { + if (!this.bindValues[columnIndex].isSet()) { + throw ExceptionFactory.createException(Messages.getString("PreparedStatement.40") + (columnIndex + 1), + MysqlErrorNumbers.SQL_STATE_WRONG_NO_OF_PARAMETERS, 0, true, null, this.session.getExceptionInterceptor()); + } + } + + @Override + public void setAsciiStream(int parameterIndex, InputStream x) { + setAsciiStream(parameterIndex, x, -1); + } + + @Override + public void setAsciiStream(int parameterIndex, InputStream x, int length) { + if (x == null) { + setNull(parameterIndex); + } else { + setBinaryStream(parameterIndex, x, length); + } + } + + @Override + public void setAsciiStream(int parameterIndex, InputStream x, long length) { + setAsciiStream(parameterIndex, x, (int) length); + this.bindValues[parameterIndex].setMysqlType(MysqlType.TEXT); // TODO was Types.CLOB, check; use length to find right TEXT type + } + + @Override + public void setBigDecimal(int parameterIndex, BigDecimal x) { + if (x == null) { + setNull(parameterIndex); + } else { + setValue(parameterIndex, StringUtils.fixDecimalExponent(x.toPlainString()), MysqlType.DECIMAL); + } + } + + @Override + public void setBigInteger(int parameterIndex, BigInteger x) { + setValue(parameterIndex, x.toString(), MysqlType.BIGINT_UNSIGNED); + } + + @Override + public void setBinaryStream(int parameterIndex, InputStream x) { + setBinaryStream(parameterIndex, x, -1); + } + + @Override + public void setBinaryStream(int parameterIndex, InputStream x, int length) { + if (x == null) { + setNull(parameterIndex); + } else { + this.bindValues[parameterIndex].setNull(false); + this.bindValues[parameterIndex].setIsStream(true); + this.bindValues[parameterIndex].setMysqlType(MysqlType.BLOB); // TODO use length to find the right BLOB type + this.bindValues[parameterIndex].setStreamValue(x, length); + } + } + + @Override + public void setBinaryStream(int parameterIndex, InputStream x, long length) { + setBinaryStream(parameterIndex, x, (int) length); + } + + @Override + public void setBlob(int parameterIndex, InputStream inputStream) { + setBinaryStream(parameterIndex, inputStream); + } + + @Override + public void setBlob(int parameterIndex, InputStream inputStream, long length) { + setBinaryStream(parameterIndex, inputStream, (int) length); + } + + @Override + public void setBlob(int parameterIndex, Blob x) { + if (x == null) { + setNull(parameterIndex); + } else { + try { + setBinaryStream(parameterIndex, x.getBinaryStream(), x.length()); + } catch (Throwable t) { + throw ExceptionFactory.createException(t.getMessage(), t, this.session.getExceptionInterceptor()); + } + } + } + + @Override + public void setBoolean(int parameterIndex, boolean x) { + setValue(parameterIndex, x ? "1" : "0", MysqlType.BOOLEAN); + } + + @Override + public void setByte(int parameterIndex, byte x) { + setValue(parameterIndex, String.valueOf(x), MysqlType.TINYINT); + } + + public void setBytes(int parameterIndex, byte[] x) { + setBytes(parameterIndex, x, true, true); + + if (x != null) { + this.bindValues[parameterIndex].setMysqlType(MysqlType.BINARY); // TODO VARBINARY ? + } + } + + public synchronized void setBytes(int parameterIndex, byte[] x, boolean checkForIntroducer, boolean escapeForMBChars) { + if (x == null) { + setNull(parameterIndex); // setNull(parameterIndex, MysqlType.BINARY); + } else { + if (this.session.getServerSession().isNoBackslashEscapesSet() + || (escapeForMBChars && this.session.getServerSession().getCharsetSettings().isMultibyteCharset(this.charEncoding))) { + + // Send as hex + + ByteArrayOutputStream bOut = new ByteArrayOutputStream((x.length * 2) + 3); + bOut.write('x'); + bOut.write('\''); + + // TODO unify with AbstractQueryBindings.hexEscapeBlock() + for (int i = 0; i < x.length; i++) { + int lowBits = (x[i] & 0xff) / 16; + int highBits = (x[i] & 0xff) % 16; + + bOut.write(HEX_DIGITS[lowBits]); + bOut.write(HEX_DIGITS[highBits]); + } + + bOut.write('\''); + + setValue(parameterIndex, bOut.toByteArray(), MysqlType.BINARY); // TODO VARBINARY ? + + // save original value for re-usage by refresher SSPS in updatable result set + setOrigValue(parameterIndex, x); + + return; + } + + // escape them + int numBytes = x.length; + + int pad = 2; + + if (checkForIntroducer) { + pad += 7; + } + + ByteArrayOutputStream bOut = new ByteArrayOutputStream(numBytes + pad); + + if (checkForIntroducer) { + bOut.write('_'); + bOut.write('b'); + bOut.write('i'); + bOut.write('n'); + bOut.write('a'); + bOut.write('r'); + bOut.write('y'); + } + bOut.write('\''); + + for (int i = 0; i < numBytes; ++i) { + byte b = x[i]; + + switch (b) { + case 0: /* Must be escaped for 'mysql' */ + bOut.write('\\'); + bOut.write('0'); + break; + case '\n': /* Must be escaped for logs */ + bOut.write('\\'); + bOut.write('n'); + break; + case '\r': + bOut.write('\\'); + bOut.write('r'); + break; + case '\\': + bOut.write('\\'); + bOut.write('\\'); + break; + case '\'': + bOut.write('\\'); + bOut.write('\''); + break; + case '"': /* Better safe than sorry */ + bOut.write('\\'); + bOut.write('"'); + break; + case '\032': /* This gives problems on Win32 */ + bOut.write('\\'); + bOut.write('Z'); + break; + default: + bOut.write(b); + } + } + + bOut.write('\''); + + setValue(parameterIndex, bOut.toByteArray(), MysqlType.BINARY); // TODO VARBINARY ? + } + } + + @Override + public void setBytesNoEscape(int parameterIndex, byte[] parameterAsBytes) { + byte[] parameterWithQuotes = StringUtils.quoteBytes(parameterAsBytes); + + setValue(parameterIndex, parameterWithQuotes, MysqlType.BINARY); // TODO VARBINARY ? + } + + @Override + public void setBytesNoEscapeNoQuotes(int parameterIndex, byte[] parameterAsBytes) { + setValue(parameterIndex, parameterAsBytes, MysqlType.BINARY); // TODO VARBINARY ? + } + + @Override + public void setCharacterStream(int parameterIndex, Reader reader) { + setCharacterStream(parameterIndex, reader, -1); + } + + @Override + public void setCharacterStream(int parameterIndex, Reader reader, int length) { + try { + if (reader == null) { + setNull(parameterIndex); + } else { + char[] c = null; + int len = 0; + + boolean useLength = this.useStreamLengthsInPrepStmts.getValue(); + + String forcedEncoding = this.session.getPropertySet().getStringProperty(PropertyKey.clobCharacterEncoding).getStringValue(); + + if (useLength && (length != -1)) { + c = new char[length]; + + int numCharsRead = Util.readFully(reader, c, length); // blocks until all read + + if (forcedEncoding == null) { + setString(parameterIndex, new String(c, 0, numCharsRead)); + } else { + setBytes(parameterIndex, StringUtils.getBytes(new String(c, 0, numCharsRead), forcedEncoding)); + } + } else { + c = new char[4096]; + + StringBuilder buf = new StringBuilder(); + + while ((len = reader.read(c)) != -1) { + buf.append(c, 0, len); + } + + if (forcedEncoding == null) { + setString(parameterIndex, buf.toString()); + } else { + setBytes(parameterIndex, StringUtils.getBytes(buf.toString(), forcedEncoding)); + } + } + + this.bindValues[parameterIndex].setMysqlType(MysqlType.TEXT); // TODO was Types.CLOB + } + } catch (UnsupportedEncodingException uec) { + throw ExceptionFactory.createException(WrongArgumentException.class, uec.toString(), uec, this.session.getExceptionInterceptor()); + } catch (IOException ioEx) { + throw ExceptionFactory.createException(ioEx.toString(), ioEx, this.session.getExceptionInterceptor()); + } + } + + @Override + public void setCharacterStream(int parameterIndex, Reader reader, long length) { + setCharacterStream(parameterIndex, reader, (int) length); + } + + @Override + public void setClob(int parameterIndex, Reader reader) { + setCharacterStream(parameterIndex, reader); + } + + @Override + public void setClob(int parameterIndex, Reader reader, long length) { + setCharacterStream(parameterIndex, reader, length); + } + + @Override + public void setClob(int i, Clob x) { + if (x == null) { + setNull(i); + } else { + try { + String forcedEncoding = this.session.getPropertySet().getStringProperty(PropertyKey.clobCharacterEncoding).getStringValue(); + + if (forcedEncoding == null) { + setString(i, x.getSubString(1L, (int) x.length())); + } else { + setBytes(i, StringUtils.getBytes(x.getSubString(1L, (int) x.length()), forcedEncoding)); + } + + this.bindValues[i].setMysqlType(MysqlType.TEXT); // TODO was Types.CLOB + } catch (Throwable t) { + throw ExceptionFactory.createException(t.getMessage(), t); + } + } + } + + @Override + public void setDate(int parameterIndex, Date x) { + setDate(parameterIndex, x, null); + } + + @Override + public void setDate(int parameterIndex, Date x, Calendar cal) { + if (x == null) { + setNull(parameterIndex); + } else if (cal != null) { + setValue(parameterIndex, TimeUtil.getSimpleDateFormat("''yyyy-MM-dd''", cal).format(x), MysqlType.DATE); + } else { + this.ddf = TimeUtil.getSimpleDateFormat(this.ddf, "''yyyy-MM-dd''", this.session.getServerSession().getDefaultTimeZone()); + setValue(parameterIndex, this.ddf.format(x), MysqlType.DATE); + } + } + + @Override + public void setDouble(int parameterIndex, double x) { + if (!this.session.getPropertySet().getBooleanProperty(PropertyKey.allowNanAndInf).getValue() + && (x == Double.POSITIVE_INFINITY || x == Double.NEGATIVE_INFINITY || Double.isNaN(x))) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("PreparedStatement.64", new Object[] { x }), + this.session.getExceptionInterceptor()); + } + setValue(parameterIndex, StringUtils.fixDecimalExponent(String.valueOf(x)), MysqlType.DOUBLE); + } + + @Override + public void setFloat(int parameterIndex, float x) { + setValue(parameterIndex, StringUtils.fixDecimalExponent(String.valueOf(x)), MysqlType.FLOAT); // TODO check; was Types.FLOAT but should be Types.REAL to map to SQL FLOAT + } + + @Override + public void setInt(int parameterIndex, int x) { + setValue(parameterIndex, String.valueOf(x), MysqlType.INT); + } + + @Override + public void setLocalDate(int parameterIndex, LocalDate x, MysqlType targetMysqlType) { + setValue(parameterIndex, "'" + x + "'", targetMysqlType); + } + + @Override + public void setLocalTime(int parameterIndex, LocalTime x, MysqlType targetMysqlType) { + if (targetMysqlType == MysqlType.DATE) { + setValue(parameterIndex, "'" + DEFAULT_DATE + "'", MysqlType.DATE); + return; + } + + if (!this.session.getServerSession().getCapabilities().serverSupportsFracSecs() || !this.sendFractionalSeconds.getValue()) { + if (x.getNano() > 0) { + x = x.withNano(0); // truncate nanoseconds + } + } else { + int fractLen = 6; // max supported length (i.e. microsecond) + if (this.columnDefinition != null && parameterIndex <= this.columnDefinition.getFields().length && parameterIndex >= 0) { + // use the column definition if available + fractLen = this.columnDefinition.getFields()[parameterIndex].getDecimals(); + } + + x = TimeUtil.adjustNanosPrecision(x, fractLen, !this.session.getServerSession().isServerTruncatesFracSecs()); + } + + DateTimeFormatter formatter = new DateTimeFormatterBuilder().appendPattern("HH:mm:ss").appendFraction(ChronoField.NANO_OF_SECOND, 0, 6, true) + .toFormatter(); + + switch (targetMysqlType) { + case TIME: + StringBuilder sb = new StringBuilder("'"); + sb.append(x.format(formatter)); + sb.append("'"); + setValue(parameterIndex, sb.toString(), targetMysqlType); + break; + case DATETIME: + case TIMESTAMP: + sb = new StringBuilder("'"); + sb.append(DEFAULT_DATE); + sb.append(" "); + sb.append(x.format(formatter)); + sb.append("'"); + setValue(parameterIndex, sb.toString(), targetMysqlType); + break; + default: + break; + } + } + + @Override + public void setDuration(int parameterIndex, Duration x, MysqlType targetMysqlType) { + if (!this.session.getServerSession().getCapabilities().serverSupportsFracSecs() || !this.sendFractionalSeconds.getValue()) { + if (x.getNano() > 0) { + x = x.isNegative() ? x.plusSeconds(1).withNanos(0) : x.withNanos(0); // truncate nanoseconds + } + } else { + int fractLen = 6; // max supported length (i.e. microsecond) + if (this.columnDefinition != null && parameterIndex <= this.columnDefinition.getFields().length && parameterIndex >= 0) { + // use the column definition if available + fractLen = this.columnDefinition.getFields()[parameterIndex].getDecimals(); + } + + x = TimeUtil.adjustNanosPrecision(x, fractLen, !this.session.getServerSession().isServerTruncatesFracSecs()); + } + + switch (targetMysqlType) { + case TIME: + StringBuilder sb = new StringBuilder("'"); + sb.append(TimeUtil.getDurationString(x)); + sb.append("'"); + setValue(parameterIndex, sb.toString(), targetMysqlType); + break; + default: + break; + } + } + + @Override + public void setLocalDateTime(int parameterIndex, LocalDateTime x, MysqlType targetMysqlType) { + if (targetMysqlType == MysqlType.DATE) { + setValue(parameterIndex, "'" + x.toLocalDate() + "'", MysqlType.DATE); + } else { + int fractLen; // max supported length (i.e. microsecond) + + switch (targetMysqlType) { + case CHAR: + case VARCHAR: + case TINYTEXT: + case TEXT: + case MEDIUMTEXT: + case LONGTEXT: + fractLen = 9; + break; + default: + fractLen = 6; + break; + } + + if (this.columnDefinition != null && parameterIndex <= this.columnDefinition.getFields().length && parameterIndex >= 0) { + // use the column definition if available + fractLen = this.columnDefinition.getFields()[parameterIndex].getDecimals(); + } + + if (!this.session.getServerSession().getCapabilities().serverSupportsFracSecs() || !this.sendFractionalSeconds.getValue()) { + if (x.getNano() > 0) { + x = x.withNano(0); // truncate nanoseconds + } + } else { + x = TimeUtil.adjustNanosPrecision(x, fractLen, !this.session.getServerSession().isServerTruncatesFracSecs()); + } + + switch (targetMysqlType) { + case TIME: + DateTimeFormatter formatter = new DateTimeFormatterBuilder().appendPattern("HH:mm:ss") + .appendFraction(ChronoField.NANO_OF_SECOND, 0, 6, true).toFormatter(); + StringBuilder sb = new StringBuilder("'"); + sb.append(x.toLocalTime().format(formatter)); + sb.append("'"); + setValue(parameterIndex, sb.toString(), targetMysqlType); + break; + case DATETIME: + case TIMESTAMP: + formatter = new DateTimeFormatterBuilder().appendPattern("yyyy-MM-dd HH:mm:ss").appendFraction(ChronoField.NANO_OF_SECOND, 0, 6, true) + .toFormatter(); + sb = new StringBuilder("'"); + sb.append(x.format(formatter)); + sb.append("'"); + setValue(parameterIndex, sb.toString(), targetMysqlType); + break; + default: + break; + } + } + } + + @Override + public void setLong(int parameterIndex, long x) { + setValue(parameterIndex, String.valueOf(x), MysqlType.BIGINT); + } + + @Override + public void setNCharacterStream(int parameterIndex, Reader value) { + setNCharacterStream(parameterIndex, value, -1); + } + + @Override + public void setNCharacterStream(int parameterIndex, Reader reader, long length) { + if (reader == null) { + setNull(parameterIndex); + } else { + try { + char[] c = null; + int len = 0; + + boolean useLength = this.useStreamLengthsInPrepStmts.getValue(); + + // Ignore "clobCharacterEncoding" because utf8 should be used this time. + + if (useLength && (length != -1)) { + c = new char[(int) length]; // can't take more than Integer.MAX_VALUE + + int numCharsRead = Util.readFully(reader, c, (int) length); // blocks until all read + setNString(parameterIndex, new String(c, 0, numCharsRead)); + + } else { + c = new char[4096]; + + StringBuilder buf = new StringBuilder(); + + while ((len = reader.read(c)) != -1) { + buf.append(c, 0, len); + } + + setNString(parameterIndex, buf.toString()); + } + + this.bindValues[parameterIndex].setMysqlType(MysqlType.TEXT); // TODO was Types.NCLOB; use length to find right TEXT type + } catch (Throwable t) { + throw ExceptionFactory.createException(t.getMessage(), t, this.session.getExceptionInterceptor()); + } + } + } + + @Override + public void setNClob(int parameterIndex, Reader reader) { + setNCharacterStream(parameterIndex, reader); + } + + @Override + public void setNClob(int parameterIndex, Reader reader, long length) { + if (reader == null) { + setNull(parameterIndex); + } else { + setNCharacterStream(parameterIndex, reader, length); + } + } + + @Override + public void setNClob(int parameterIndex, NClob value) { + if (value == null) { + setNull(parameterIndex); + } else { + try { + setNCharacterStream(parameterIndex, value.getCharacterStream(), value.length()); + } catch (Throwable t) { + throw ExceptionFactory.createException(t.getMessage(), t, this.session.getExceptionInterceptor()); + } + } + } + + @Override + public void setNString(int parameterIndex, String x) { + if (x == null) { + setNull(parameterIndex); + } else { + if (this.charEncoding.equalsIgnoreCase("UTF-8") || this.charEncoding.equalsIgnoreCase("utf8")) { + setString(parameterIndex, x); + return; + } + + int stringLength = x.length(); + // Ignore sql_mode=NO_BACKSLASH_ESCAPES in current implementation. + + // Add introducer _utf8 for NATIONAL CHARACTER + StringBuilder buf = new StringBuilder((int) (x.length() * 1.1 + 4)); + buf.append("_utf8"); + buf.append('\''); + + // + // Note: buf.append(char) is _faster_ than appending in blocks, because the block append requires a System.arraycopy().... go figure... + // + + for (int i = 0; i < stringLength; ++i) { + char c = x.charAt(i); + + switch (c) { + case 0: /* Must be escaped for 'mysql' */ + buf.append('\\'); + buf.append('0'); + break; + case '\n': /* Must be escaped for logs */ + buf.append('\\'); + buf.append('n'); + break; + case '\r': + buf.append('\\'); + buf.append('r'); + break; + case '\\': + buf.append('\\'); + buf.append('\\'); + break; + case '\'': + buf.append('\\'); + buf.append('\''); + break; + case '"': /* Better safe than sorry */ + if (this.session.getServerSession().useAnsiQuotedIdentifiers()) { + buf.append('\\'); + } + buf.append('"'); + break; + case '\032': /* This gives problems on Win32 */ + buf.append('\\'); + buf.append('Z'); + break; + default: + buf.append(c); + } + } + + buf.append('\''); + + byte[] parameterAsBytes = this.isLoadDataQuery ? StringUtils.getBytes(buf.toString()) : StringUtils.getBytes(buf.toString(), "UTF-8"); + + setValue(parameterIndex, parameterAsBytes, MysqlType.VARCHAR); // TODO was Types.NVARCHAR + } + } + + @Override + public synchronized void setNull(int parameterIndex) { + setValue(parameterIndex, "null", MysqlType.NULL); + this.bindValues[parameterIndex].setNull(true); + } + + @Override + public void setShort(int parameterIndex, short x) { + setValue(parameterIndex, String.valueOf(x), MysqlType.SMALLINT); + } + + @Override + public void setString(int parameterIndex, String x) { + if (x == null) { + setNull(parameterIndex); + } else { + int stringLength = x.length(); + + if (this.session.getServerSession().isNoBackslashEscapesSet()) { + // Scan for any nasty chars + + boolean needsHexEscape = isEscapeNeededForString(x, stringLength); + + if (!needsHexEscape) { + StringBuilder quotedString = new StringBuilder(x.length() + 2); + quotedString.append('\''); + quotedString.append(x); + quotedString.append('\''); + + byte[] parameterAsBytes = this.isLoadDataQuery ? StringUtils.getBytes(quotedString.toString()) + : StringUtils.getBytes(quotedString.toString(), this.charEncoding); + setValue(parameterIndex, parameterAsBytes, MysqlType.VARCHAR); + + } else { + byte[] parameterAsBytes = this.isLoadDataQuery ? StringUtils.getBytes(x) : StringUtils.getBytes(x, this.charEncoding); + setBytes(parameterIndex, parameterAsBytes); + } + + return; + } + + String parameterAsString = x; + boolean needsQuoted = true; + + if (this.isLoadDataQuery || isEscapeNeededForString(x, stringLength)) { + needsQuoted = false; // saves an allocation later + + StringBuilder buf = new StringBuilder((int) (x.length() * 1.1)); + + buf.append('\''); + + // + // Note: buf.append(char) is _faster_ than appending in blocks, because the block append requires a System.arraycopy().... go figure... + // + + for (int i = 0; i < stringLength; ++i) { + char c = x.charAt(i); + + switch (c) { + case 0: /* Must be escaped for 'mysql' */ + buf.append('\\'); + buf.append('0'); + break; + case '\n': /* Must be escaped for logs */ + buf.append('\\'); + buf.append('n'); + break; + case '\r': + buf.append('\\'); + buf.append('r'); + break; + case '\\': + buf.append('\\'); + buf.append('\\'); + break; + case '\'': + buf.append('\''); + buf.append('\''); + break; + case '"': /* Better safe than sorry */ + if (this.session.getServerSession().useAnsiQuotedIdentifiers()) { + buf.append('\\'); + } + buf.append('"'); + break; + case '\032': /* This gives problems on Win32 */ + buf.append('\\'); + buf.append('Z'); + break; + case '\u00a5': + case '\u20a9': + // escape characters interpreted as backslash by mysql + if (this.charsetEncoder != null) { + CharBuffer cbuf = CharBuffer.allocate(1); + ByteBuffer bbuf = ByteBuffer.allocate(1); + cbuf.put(c); + cbuf.position(0); + this.charsetEncoder.encode(cbuf, bbuf, true); + if (bbuf.get(0) == '\\') { + buf.append('\\'); + } + } + buf.append(c); + break; + + default: + buf.append(c); + } + } + + buf.append('\''); + + parameterAsString = buf.toString(); + } + + byte[] parameterAsBytes = this.isLoadDataQuery ? StringUtils.getBytes(parameterAsString) + : (needsQuoted ? StringUtils.getBytesWrapped(parameterAsString, '\'', '\'', this.charEncoding) + : StringUtils.getBytes(parameterAsString, this.charEncoding)); + + setValue(parameterIndex, parameterAsBytes, MysqlType.VARCHAR); + } + } + + private boolean isEscapeNeededForString(String x, int stringLength) { + boolean needsHexEscape = false; + + for (int i = 0; i < stringLength; ++i) { + char c = x.charAt(i); + + switch (c) { + case 0: /* Must be escaped for 'mysql' */ + case '\n': /* Must be escaped for logs */ + case '\r': + case '\\': + case '\'': + case '"': /* Better safe than sorry */ + case '\032': /* This gives problems on Win32 */ + needsHexEscape = true; + break; + } + + if (needsHexEscape) { + break; // no need to scan more + } + } + return needsHexEscape; + } + + public void setTime(int parameterIndex, Time x, Calendar cal) { + if (x == null) { + setNull(parameterIndex); + return; + } + + String formatStr = this.session.getServerSession().getCapabilities().serverSupportsFracSecs() && this.sendFractionalSeconds.getValue() + && this.sendFractionalSecondsForTime.getValue() && TimeUtil.hasFractionalSeconds(x) ? "''HH:mm:ss.SSS''" : "''HH:mm:ss''"; + + if (cal != null) { + setValue(parameterIndex, TimeUtil.getSimpleDateFormat(formatStr, cal).format(x), MysqlType.TIME); + } else { + this.tdf = TimeUtil.getSimpleDateFormat(this.tdf, formatStr, this.session.getServerSession().getDefaultTimeZone()); + setValue(parameterIndex, this.tdf.format(x), MysqlType.TIME); + } + } + + public void setTime(int parameterIndex, Time x) { + setTime(parameterIndex, x, null); + } + + @Override + public void bindTimestamp(int parameterIndex, Timestamp x, Calendar targetCalendar, int fractionalLength, MysqlType targetMysqlType) { + if (fractionalLength < 0) { + // default to 6 fractional positions + fractionalLength = 6; + } + + x = TimeUtil.adjustNanosPrecision(x, fractionalLength, !this.session.getServerSession().isServerTruncatesFracSecs()); + + StringBuffer buf = new StringBuffer(); + + if (targetCalendar != null) { + buf.append(TimeUtil.getSimpleDateFormat("''yyyy-MM-dd HH:mm:ss", targetCalendar).format(x)); + } else { + this.tsdf = TimeUtil.getSimpleDateFormat(this.tsdf, "''yyyy-MM-dd HH:mm:ss", + targetMysqlType == MysqlType.TIMESTAMP && this.preserveInstants.getValue() ? this.session.getServerSession().getSessionTimeZone() + : this.session.getServerSession().getDefaultTimeZone()); + buf.append(this.tsdf.format(x)); + } + + if (this.session.getServerSession().getCapabilities().serverSupportsFracSecs() && x.getNanos() > 0) { + buf.append('.'); + buf.append(TimeUtil.formatNanos(x.getNanos(), 6)); + } + buf.append('\''); + + setValue(parameterIndex, buf.toString(), targetMysqlType); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/CoreSession.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/CoreSession.java new file mode 100644 index 0000000..15934ea --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/CoreSession.java @@ -0,0 +1,221 @@ +/* + * Copyright (c) 2015, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.net.SocketAddress; + +import com.mysql.cj.conf.HostInfo; +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.conf.RuntimeProperty; +import com.mysql.cj.exceptions.CJOperationNotSupportedException; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.ExceptionInterceptor; +import com.mysql.cj.log.Log; +import com.mysql.cj.log.LogFactory; +import com.mysql.cj.log.NullLogger; +import com.mysql.cj.log.ProfilerEventHandler; +import com.mysql.cj.protocol.Message; +import com.mysql.cj.protocol.Protocol; +import com.mysql.cj.protocol.ServerSession; +import com.mysql.cj.util.Util; + +public abstract class CoreSession implements Session { + + protected PropertySet propertySet; + protected ExceptionInterceptor exceptionInterceptor; + + /** The logger we're going to use */ + protected transient Log log; + + /** Null logger shared by all connections at startup */ + protected static final Log NULL_LOGGER = new NullLogger(Log.LOGGER_INSTANCE_NAME); + + protected transient Protocol protocol; + protected MessageBuilder messageBuilder; + + /** The point in time when this connection was created */ + protected long connectionCreationTimeMillis = 0; + protected HostInfo hostInfo = null; + + protected RuntimeProperty gatherPerfMetrics; + protected RuntimeProperty characterEncoding; + protected RuntimeProperty disconnectOnExpiredPasswords; + protected RuntimeProperty cacheServerConfiguration; + protected RuntimeProperty autoReconnect; + protected RuntimeProperty autoReconnectForPools; + protected RuntimeProperty maintainTimeStats; + + /** The max-rows setting for current session */ + protected int sessionMaxRows = -1; + + /** The event sink to use for profiling */ + private ProfilerEventHandler eventSink; + + public CoreSession(HostInfo hostInfo, PropertySet propSet) { + this.connectionCreationTimeMillis = System.currentTimeMillis(); + this.hostInfo = hostInfo; + this.propertySet = propSet; + + this.gatherPerfMetrics = getPropertySet().getBooleanProperty(PropertyKey.gatherPerfMetrics); + this.characterEncoding = getPropertySet().getStringProperty(PropertyKey.characterEncoding); + this.disconnectOnExpiredPasswords = getPropertySet().getBooleanProperty(PropertyKey.disconnectOnExpiredPasswords); + this.cacheServerConfiguration = getPropertySet().getBooleanProperty(PropertyKey.cacheServerConfiguration); + this.autoReconnect = getPropertySet().getBooleanProperty(PropertyKey.autoReconnect); + this.autoReconnectForPools = getPropertySet().getBooleanProperty(PropertyKey.autoReconnectForPools); + this.maintainTimeStats = getPropertySet().getBooleanProperty(PropertyKey.maintainTimeStats); + + this.log = LogFactory.getLogger(getPropertySet().getStringProperty(PropertyKey.logger).getStringValue(), Log.LOGGER_INSTANCE_NAME); + } + + @Override + public void changeUser(String user, String password, String database) { + // reset maxRows to default value + this.sessionMaxRows = -1; + + this.protocol.changeUser(user, password, database); + } + + @Override + public PropertySet getPropertySet() { + return this.propertySet; + } + + @Override + public ExceptionInterceptor getExceptionInterceptor() { + return this.exceptionInterceptor; + } + + @Override + public void setExceptionInterceptor(ExceptionInterceptor exceptionInterceptor) { + this.exceptionInterceptor = exceptionInterceptor; + } + + @Override + public Log getLog() { + return this.log; + } + + public HostInfo getHostInfo() { + return this.hostInfo; + } + + @SuppressWarnings("unchecked") + @Override + public MessageBuilder getMessageBuilder() { + return (MessageBuilder) this.messageBuilder; + } + + @Override + public ServerSession getServerSession() { + return this.protocol.getServerSession(); + } + + @Override + public boolean versionMeetsMinimum(int major, int minor, int subminor) { + return this.protocol.versionMeetsMinimum(major, minor, subminor); + } + + @Override + public long getThreadId() { + return this.protocol.getServerSession().getCapabilities().getThreadId(); + } + + @Override + public void quit() { + if (this.eventSink != null) { + this.eventSink.destroy(); + this.eventSink = null; + } + } + + @Override + public void forceClose() { + if (this.eventSink != null) { + this.eventSink.destroy(); + this.eventSink = null; + } + } + + public boolean isSetNeededForAutoCommitMode(boolean autoCommitFlag) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not supported"); + } + + @Override + public ProfilerEventHandler getProfilerEventHandler() { + if (this.eventSink == null) { + synchronized (this) { + if (this.eventSink == null) { // check again to ensure that other thread didn't set it already + this.eventSink = (ProfilerEventHandler) Util.getInstance( + this.propertySet.getStringProperty(PropertyKey.profilerEventHandler).getStringValue(), new Class[0], new Object[0], + this.exceptionInterceptor); + + this.eventSink.init(this.log); + } + } + } + return this.eventSink; + } + + @Override + public boolean isSSLEstablished() { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not supported"); + } + + @Override + public SocketAddress getRemoteSocketAddress() { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not supported"); + } + + @Override + public void addListener(SessionEventListener l) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not supported"); + } + + @Override + public void removeListener(SessionEventListener l) { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not supported"); + } + + @Override + public String getIdentifierQuoteString() { + throw ExceptionFactory.createException(CJOperationNotSupportedException.class, "Not supported"); + } + + @Override + public DataStoreMetadata getDataStoreMetadata() { + return new DataStoreMetadataImpl(this); + } + + @Override + public String getQueryTimingUnits() { + return this.protocol.getQueryTimingUnits(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/DataStoreMetadataImpl.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/DataStoreMetadataImpl.java new file mode 100644 index 0000000..46fcfac --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/DataStoreMetadataImpl.java @@ -0,0 +1,83 @@ +/* + * Copyright (c) 2018, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.util.List; +import java.util.function.Function; +import java.util.stream.Collectors; + +import com.mysql.cj.result.LongValueFactory; +import com.mysql.cj.xdevapi.ExprUnparser; + +public class DataStoreMetadataImpl implements DataStoreMetadata { + + private Session session; + + public DataStoreMetadataImpl(Session sess) { + this.session = sess; + } + + public boolean schemaExists(String schemaName) { + StringBuilder stmt = new StringBuilder("select count(*) from information_schema.schemata where schema_name = '"); + // TODO: verify quoting rules + stmt.append(schemaName.replaceAll("'", "\\'")); + stmt.append("'"); + + Function rowToLong = r -> r.getValue(0, new LongValueFactory(this.session.getPropertySet())); + List counters = this.session.query(this.session.getMessageBuilder().buildSqlStatement(stmt.toString()), null, rowToLong, Collectors.toList()); + return 1 == counters.get(0); + } + + public boolean tableExists(String schemaName, String tableName) { + StringBuilder stmt = new StringBuilder("select count(*) from information_schema.tables where table_schema = '"); + // TODO: verify quoting rules + stmt.append(schemaName.replaceAll("'", "\\'")); + stmt.append("' and table_name = '"); + stmt.append(tableName.replaceAll("'", "\\'")); + stmt.append("'"); + + Function rowToLong = r -> r.getValue(0, new LongValueFactory(this.session.getPropertySet())); + List counters = this.session.query(this.session.getMessageBuilder().buildSqlStatement(stmt.toString()), null, rowToLong, Collectors.toList()); + return 1 == counters.get(0); + } + + @Override + public long getTableRowCount(String schemaName, String tableName) { + StringBuilder stmt = new StringBuilder("select count(*) from "); + stmt.append(ExprUnparser.quoteIdentifier(schemaName)); + stmt.append("."); + stmt.append(ExprUnparser.quoteIdentifier(tableName)); + + Function rowToLong = r -> r.getValue(0, new LongValueFactory(this.session.getPropertySet())); + List counters = this.session.query(this.session.getMessageBuilder().buildSqlStatement(stmt.toString()), null, rowToLong, Collectors.toList()); + return counters.get(0); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/LicenseConfiguration.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/LicenseConfiguration.java new file mode 100644 index 0000000..7eb30cd --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/LicenseConfiguration.java @@ -0,0 +1,59 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.util.Map; + +import com.mysql.cj.exceptions.CJException; + +/** + * Used in commercially-licensed clients that require connections to commercially-licensed servers as part of the licensing terms. + */ +public class LicenseConfiguration { + + /** + * Used in commercially-licensed clients that require connections to + * commercially-licensed servers as part of the licensing terms. + * + * @param serverVariables + * a Map of the output of 'show variables' from the server we're + * connecting to. + * + * @throws CJException + * if commercial license is required, but not found + */ + public static void checkLicenseType(Map serverVariables) { + // we don't check anything by default + } + + private LicenseConfiguration() { + // this is a static utility class + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/MysqlxSession.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/MysqlxSession.java new file mode 100644 index 0000000..6c7d7db --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/MysqlxSession.java @@ -0,0 +1,176 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.io.IOException; +import java.util.Iterator; +import java.util.Spliterators; +import java.util.concurrent.CompletableFuture; +import java.util.function.Function; +import java.util.function.Predicate; +import java.util.stream.Collector; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +import com.mysql.cj.conf.HostInfo; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.CJCommunicationsException; +import com.mysql.cj.protocol.ColumnDefinition; +import com.mysql.cj.protocol.Message; +import com.mysql.cj.protocol.ResultBuilder; +import com.mysql.cj.protocol.x.StatementExecuteOkBuilder; +import com.mysql.cj.protocol.x.XProtocol; +import com.mysql.cj.protocol.x.XProtocolError; +import com.mysql.cj.protocol.x.XProtocolRowInputStream; +import com.mysql.cj.result.Row; +import com.mysql.cj.xdevapi.PreparableStatement; + +public class MysqlxSession extends CoreSession { + + public MysqlxSession(HostInfo hostInfo, PropertySet propSet) { + super(hostInfo, propSet); + + // create protocol instance + this.protocol = new XProtocol(hostInfo, propSet); + + this.messageBuilder = this.protocol.getMessageBuilder(); + + this.protocol.connect(hostInfo.getUser(), hostInfo.getPassword(), hostInfo.getDatabase()); + } + + public MysqlxSession(XProtocol prot) { + super(null, prot.getPropertySet()); + this.protocol = prot; + this.messageBuilder = this.protocol.getMessageBuilder(); + } + + @Override + public String getProcessHost() { + return this.protocol.getSocketConnection().getHost(); + } + + public int getPort() { + return this.protocol.getSocketConnection().getPort(); + } + + public XProtocol getProtocol() { + return (XProtocol) this.protocol; + } + + @Override + public void quit() { + try { + this.protocol.close(); + } catch (IOException ex) { + throw new CJCommunicationsException(ex); + } + super.quit(); + } + + public boolean isClosed() { + return !((XProtocol) this.protocol).isOpen(); + } + + /** + * Check if current session is using a MySQL server that supports prepared statements. + * + * @return + * {@code true} if the MySQL server in use supports prepared statements + */ + public boolean supportsPreparedStatements() { + return ((XProtocol) this.protocol).supportsPreparedStatements(); + } + + /** + * Check if enough statements were executed in the underlying MySQL server so that another prepare statement attempt should be done. + * + * @return + * {@code true} if enough executions have been done since last time a prepared statement failed to be prepared + */ + public boolean readyForPreparingStatements() { + return ((XProtocol) this.protocol).readyForPreparingStatements(); + } + + /** + * Return an id to be used as a client-managed prepared statement id. + * + * @param preparableStatement + * {@link PreparableStatement} + * @return a new identifier to be used as prepared statement id + */ + public int getNewPreparedStatementId(PreparableStatement preparableStatement) { + return ((XProtocol) this.protocol).getNewPreparedStatementId(preparableStatement); + } + + /** + * Free a prepared statement id so that it can be reused. + * + * @param preparedStatementId + * the prepared statement id to release + */ + public void freePreparedStatementId(int preparedStatementId) { + ((XProtocol) this.protocol).freePreparedStatementId(preparedStatementId); + } + + /** + * Propagate to the underlying protocol instance that preparing a statement on the connected server failed. + * + * @param preparedStatementId + * the id of the prepared statement that failed to be prepared + * @param e + * {@link XProtocolError} + * @return + * {@code true} if the exception was properly handled + */ + public boolean failedPreparingStatement(int preparedStatementId, XProtocolError e) { + return ((XProtocol) this.protocol).failedPreparingStatement(preparedStatementId, e); + } + + public RES query(M message, Predicate rowFilter, Function rowMapper, Collector collector) { + this.protocol.send(message, 0); + ColumnDefinition metadata = this.protocol.readMetadata(); + Iterator ris = new XProtocolRowInputStream(metadata, (XProtocol) this.protocol, null); + Stream stream = StreamSupport.stream(Spliterators.spliteratorUnknownSize(ris, 0), false); + if (rowFilter != null) { + stream = stream.filter(rowFilter); + } + RES result = stream.map(rowMapper).collect(collector); + this.protocol.readQueryResult(new StatementExecuteOkBuilder()); + return result; + } + + public R query(M message, ResultBuilder resultBuilder) { + return ((XProtocol) this.protocol).query(message, resultBuilder); + } + + public CompletableFuture queryAsync(M message, ResultBuilder resultBuilder) { + return ((XProtocol) this.protocol).queryAsync(message, resultBuilder); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/NativeCharsetSettings.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/NativeCharsetSettings.java new file mode 100644 index 0000000..77b2f15 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/NativeCharsetSettings.java @@ -0,0 +1,724 @@ +/* + * Copyright (c) 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.OutputStreamWriter; +import java.nio.ByteBuffer; +import java.nio.CharBuffer; +import java.nio.charset.Charset; +import java.nio.charset.CharsetEncoder; +import java.util.Collections; +import java.util.HashMap; +import java.util.HashSet; +import java.util.Locale; +import java.util.Map; +import java.util.Set; + +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.conf.RuntimeProperty; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.WrongArgumentException; +import com.mysql.cj.protocol.Resultset; +import com.mysql.cj.protocol.Resultset.Type; +import com.mysql.cj.protocol.ServerCapabilities; +import com.mysql.cj.protocol.ServerSession; +import com.mysql.cj.protocol.a.NativeConstants; +import com.mysql.cj.protocol.a.NativeMessageBuilder; +import com.mysql.cj.protocol.a.NativePacketPayload; +import com.mysql.cj.protocol.a.ResultsetFactory; +import com.mysql.cj.result.IntegerValueFactory; +import com.mysql.cj.result.Row; +import com.mysql.cj.result.StringValueFactory; +import com.mysql.cj.result.ValueFactory; +import com.mysql.cj.util.StringUtils; + +public class NativeCharsetSettings extends CharsetMapping implements CharsetSettings { + + private NativeSession session; + + private ServerSession serverSession; + + public Map collationIndexToCollationName = null; + public Map collationNameToCollationIndex = null; + public Map collationIndexToCharsetName = null; + public Map charsetNameToMblen = null; + public Map charsetNameToJavaEncoding = null; + public Map charsetNameToCollationIndex = null; + public Map javaEncodingUcToCharsetName = null; + public Set multibyteEncodings = null; + + private Integer sessionCollationIndex = null; + + /** + * What character set is the metadata returned in? + */ + private String metadataEncoding = null; + private int metadataCollationIndex; + + /** + * The (Java) encoding used to interpret error messages received from the server. + * We use character_set_results (since MySQL 5.5) if it is not null or UTF-8 otherwise. + */ + private String errorMessageEncoding = "Cp1252"; // to begin with, changes after we talk to the server + + protected RuntimeProperty characterEncoding; + protected RuntimeProperty passwordCharacterEncoding; + protected RuntimeProperty characterSetResults; + protected RuntimeProperty connectionCollation; + protected RuntimeProperty cacheServerConfiguration; + + /** + * If a CharsetEncoder is required for escaping. Needed for SJIS and related problems with \u00A5. + */ + private boolean requiresEscapingEncoder; + + private NativeMessageBuilder commandBuilder = null; + + private static final Map> customCollationIndexToCollationNameByUrl = new HashMap<>(); + private static final Map> customCollationNameToCollationIndexByUrl = new HashMap<>(); + + /** + * Actual collation index to mysql charset name map of user defined charsets for given server URLs. + */ + private static final Map> customCollationIndexToCharsetNameByUrl = new HashMap<>(); + + /** + * Actual mysql charset name to mblen map of user defined charsets for given server URLs. + */ + private static final Map> customCharsetNameToMblenByUrl = new HashMap<>(); + + private static final Map> customCharsetNameToJavaEncodingByUrl = new HashMap<>(); + private static final Map> customCharsetNameToCollationIndexByUrl = new HashMap<>(); + private static final Map> customJavaEncodingUcToCharsetNameByUrl = new HashMap<>(); + private static final Map> customMultibyteEncodingsByUrl = new HashMap<>(); + + /** + * We store the platform 'encoding' here, only used to avoid munging filenames for LOAD DATA LOCAL INFILE... + */ + private static Charset jvmPlatformCharset = null; + + /** + * Does the character set of this connection match the character set of the platform + */ + private boolean platformDbCharsetMatches = true; // changed once we've connected. + + static { + OutputStreamWriter outWriter = null; + // Use the I/O system to get the encoding (if possible), to avoid security restrictions on System.getProperty("file.encoding") in applets (why is that restricted?) + try { + outWriter = new OutputStreamWriter(new ByteArrayOutputStream()); + jvmPlatformCharset = Charset.forName(outWriter.getEncoding()); + } finally { + try { + if (outWriter != null) { + outWriter.close(); + } + } catch (IOException ioEx) { + // ignore + } + } + } + + private NativeMessageBuilder getCommandBuilder() { + if (this.commandBuilder == null) { + this.commandBuilder = new NativeMessageBuilder(this.serverSession.supportsQueryAttributes()); + } + return this.commandBuilder; + } + + /** + * Determines if the database charset is the same as the platform charset + */ + private void checkForCharsetMismatch() { + String characterEncodingValue = this.characterEncoding.getValue(); + if (characterEncodingValue != null) { + Charset characterEncodingCs = Charset.forName(characterEncodingValue); + Charset encodingToCheck = jvmPlatformCharset; + + if (encodingToCheck == null) { + encodingToCheck = Charset.forName(Constants.PLATFORM_ENCODING); + } + + this.platformDbCharsetMatches = encodingToCheck == null ? false : encodingToCheck.equals(characterEncodingCs); + } + } + + @Override + public boolean doesPlatformDbCharsetMatches() { + return this.platformDbCharsetMatches; + } + + public NativeCharsetSettings(NativeSession sess) { + this.session = sess; + this.serverSession = this.session.getServerSession(); + + this.characterEncoding = sess.getPropertySet().getStringProperty(PropertyKey.characterEncoding); + this.characterSetResults = this.session.getPropertySet().getProperty(PropertyKey.characterSetResults); + this.passwordCharacterEncoding = this.session.getPropertySet().getStringProperty(PropertyKey.passwordCharacterEncoding); + this.connectionCollation = this.session.getPropertySet().getStringProperty(PropertyKey.connectionCollation); + this.cacheServerConfiguration = sess.getPropertySet().getBooleanProperty(PropertyKey.cacheServerConfiguration); + + tryAndFixEncoding(this.characterEncoding, true); + tryAndFixEncoding(this.passwordCharacterEncoding, true); + if (!"null".equalsIgnoreCase(this.characterSetResults.getValue())) { // the "null" instead of an encoding name is allowed for characterSetResults + tryAndFixEncoding(this.characterSetResults, false); + } + } + + /** + * Attempt to use the encoding, and bail out if it can't be used. + * + * @param encodingProperty + * connection property containing the Java encoding to try + * @param replaceImpermissibleEncodings + * The character_set_client system variable cannot be set to ucs2, utf16, utf16le, utf32 charsets. If "true" the corresponding connection + * property value will be replaced with "UTF-8" + */ + private void tryAndFixEncoding(RuntimeProperty encodingProperty, boolean replaceImpermissibleEncodings) { + String oldEncoding = encodingProperty.getValue(); + if (oldEncoding != null) { + if (replaceImpermissibleEncodings && ("UnicodeBig".equalsIgnoreCase(oldEncoding) || "UTF-16".equalsIgnoreCase(oldEncoding) + || "UTF-16LE".equalsIgnoreCase(oldEncoding) || "UTF-32".equalsIgnoreCase(oldEncoding))) { + encodingProperty.setValue("UTF-8"); + } else { + try { + StringUtils.getBytes("abc", oldEncoding); + } catch (WrongArgumentException waEx) { + // Try the MySQL character set name, then.... + String newEncoding = getStaticJavaEncodingForMysqlCharset(oldEncoding); + if (newEncoding == null) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("StringUtils.0", new Object[] { oldEncoding }), + this.session.getExceptionInterceptor()); + } + StringUtils.getBytes("abc", newEncoding); + encodingProperty.setValue(newEncoding); + } + } + } + } + + @Override + public int configurePreHandshake(boolean reset) { + if (reset) { + this.sessionCollationIndex = null; + } + + // Avoid the second execution of this method + if (this.sessionCollationIndex != null) { + return this.sessionCollationIndex; + } + + ServerCapabilities capabilities = this.serverSession.getCapabilities(); + String encoding = this.passwordCharacterEncoding.getStringValue(); + if (encoding == null) { + String connectionColl = this.connectionCollation.getStringValue(); + if ((connectionColl == null || (this.sessionCollationIndex = getStaticCollationIndexForCollationName(connectionColl)) == null) + && (encoding = this.characterEncoding.getValue()) == null) { + // If none of "passwordCharacterEncoding", "connectionCollation" or "characterEncoding" is specified then use UTF-8. + // It would be better to use the server default collation here, to avoid unnecessary SET NAMES queries after the handshake if server + // default charset if not utf8, but we can not do it until server Bug#32729185 is fixed. Server cuts collation index to lower byte and, for example, + // if the server is started with character-set-server=utf8mb4 and collation-server=utf8mb4_is_0900_ai_ci (collation index 257) the Protocol::HandshakeV10 + // will contain character_set=1, "big5_chinese_ci". This is true not only for MySQL 8.0, where built-in collations with indexes > 255 were first introduced, + // but also other server series would be affected when configured with custom collations, for which the reserved collation id range is >= 1024. + this.sessionCollationIndex = MYSQL_COLLATION_INDEX_utf8mb4_0900_ai_ci; + } + } + + if (this.sessionCollationIndex == null) { + if ((this.sessionCollationIndex = getStaticCollationIndexForJavaEncoding(encoding, capabilities.getServerVersion())) == 0) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("StringUtils.0", new Object[] { encoding })); + } + } + + if (this.sessionCollationIndex > Constants.UNSIGNED_BYTE_MAX_VALUE // + || isStaticImpermissibleCollation(this.sessionCollationIndex)) { // At this point, impermissible charset can be set only with "connectionCollation". + this.sessionCollationIndex = MYSQL_COLLATION_INDEX_utf8mb4_0900_ai_ci; + } + + if (this.sessionCollationIndex == MYSQL_COLLATION_INDEX_utf8mb4_0900_ai_ci + && !capabilities.getServerVersion().meetsMinimum(new ServerVersion(8, 0, 1))) { + this.sessionCollationIndex = MYSQL_COLLATION_INDEX_utf8mb4_general_ci; // use utf8mb4_general_ci instead of utf8mb4_0900_ai_ci for old servers + } + + // error messages are returned according to character_set_results which, at this point, is set from the response packet + this.errorMessageEncoding = getStaticJavaEncodingForCollationIndex(this.sessionCollationIndex); + this.serverSession.getServerVariables().put(CHARACTER_SET_RESULTS, getStaticMysqlCharsetNameForCollationIndex(this.sessionCollationIndex)); + + return this.sessionCollationIndex; + } + + @Override + public void configurePostHandshake(boolean dontCheckServerMatch) { + + buildCollationMapping(); + + /* + * Configuring characterEncoding. + */ + + String requiredCollation = this.connectionCollation.getStringValue(); + String requiredEncoding = this.characterEncoding.getValue(); + String passwordEncoding = this.passwordCharacterEncoding.getValue(); + Integer requiredCollationIndex; + String sessionCharsetName = getServerDefaultCharset(); + String sessionCollationClause = ""; + + try { + + // connectionCollation overrides the characterEncoding value + if (requiredCollation != null && (requiredCollationIndex = getCollationIndexForCollationName(requiredCollation)) != null) { + if (isImpermissibleCollation(requiredCollationIndex)) { + if (this.serverSession.getCapabilities().getServerVersion().meetsMinimum(new ServerVersion(8, 0, 1))) { + requiredCollationIndex = MYSQL_COLLATION_INDEX_utf8mb4_0900_ai_ci; + requiredCollation = "utf8mb4_0900_ai_ci"; + } else { + requiredCollationIndex = MYSQL_COLLATION_INDEX_utf8mb4_general_ci; + requiredCollation = "utf8mb4_general_ci"; + } + } + sessionCollationClause = " COLLATE " + requiredCollation; + sessionCharsetName = getMysqlCharsetNameForCollationIndex(requiredCollationIndex); + requiredEncoding = getJavaEncodingForCollationIndex(requiredCollationIndex, requiredEncoding); + this.sessionCollationIndex = requiredCollationIndex; + } + + if (requiredEncoding != null) { // If either connectionCollation or characterEncoding is defined. + if (sessionCollationClause.length() == 0) { // If no connectionCollation is defined. + sessionCharsetName = getMysqlCharsetForJavaEncoding(requiredEncoding.toUpperCase(Locale.ENGLISH), this.serverSession.getServerVersion()); + } + + } else { // Neither connectionCollation nor characterEncoding are defined. + // Collations with index > 255 don't fit into server greeting packet. + // Now we can set sessionCollationIndex according to "collation_server" value. + if (!StringUtils.isNullOrEmpty(passwordEncoding)) { + if (this.serverSession.getCapabilities().getServerVersion().meetsMinimum(new ServerVersion(8, 0, 1))) { + this.sessionCollationIndex = MYSQL_COLLATION_INDEX_utf8mb4_0900_ai_ci; // We can't do more, just trying to use utf8mb4_0900_ai_ci because the most of collations in that range are utf8mb4. + requiredCollation = "utf8mb4_0900_ai_ci"; + } else { + this.sessionCollationIndex = MYSQL_COLLATION_INDEX_utf8mb4_general_ci; + requiredCollation = "utf8mb4_general_ci"; + } + sessionCollationClause = " COLLATE " + getCollationNameForCollationIndex(this.sessionCollationIndex); + } + + if (((requiredEncoding = getJavaEncodingForCollationIndex(this.sessionCollationIndex, requiredEncoding)) == null)) { + // if there is no mapping for default collation index leave characterEncoding as specified by user + throw ExceptionFactory.createException(Messages.getString("Connection.5", new Object[] { this.sessionCollationIndex.toString() }), + this.session.getExceptionInterceptor()); + } + + sessionCharsetName = getMysqlCharsetNameForCollationIndex(this.sessionCollationIndex); + } + + } catch (ArrayIndexOutOfBoundsException outOfBoundsEx) { + throw ExceptionFactory.createException(Messages.getString("Connection.6", new Object[] { this.sessionCollationIndex }), + this.session.getExceptionInterceptor()); + } + + this.characterEncoding.setValue(requiredEncoding); + + if (sessionCharsetName != null) { + boolean isCharsetDifferent = !characterSetNamesMatches(sessionCharsetName); + boolean isCollationDifferent = sessionCollationClause.length() > 0 + && !requiredCollation.equalsIgnoreCase(this.serverSession.getServerVariable(COLLATION_CONNECTION)); + if (dontCheckServerMatch || isCharsetDifferent || isCollationDifferent) { + this.session.sendCommand(getCommandBuilder().buildComQuery(null, "SET NAMES " + sessionCharsetName + sessionCollationClause), false, 0); + this.serverSession.getServerVariables().put(CHARACTER_SET_CLIENT, sessionCharsetName); + this.serverSession.getServerVariables().put(CHARACTER_SET_CONNECTION, sessionCharsetName); + } + } + + /* + * Configuring characterSetResults. + * + * We know how to deal with any charset coming back from the database, so tell the server not to do conversion + * if the user hasn't 'forced' a result-set character set. + */ + + String sessionResultsCharset = this.serverSession.getServerVariable(CHARACTER_SET_RESULTS); + String characterSetResultsValue = this.characterSetResults.getValue(); + if (StringUtils.isNullOrEmpty(characterSetResultsValue) || "null".equalsIgnoreCase(characterSetResultsValue)) { + if (!StringUtils.isNullOrEmpty(sessionResultsCharset) && !"NULL".equalsIgnoreCase(sessionResultsCharset)) { + this.session.sendCommand(getCommandBuilder().buildComQuery(null, "SET character_set_results = NULL"), false, 0); + this.serverSession.getServerVariables().put(CHARACTER_SET_RESULTS, null); + } + + String defaultMetadataCharsetMysql = this.serverSession.getServerVariable("character_set_system"); + this.metadataEncoding = defaultMetadataCharsetMysql != null ? getJavaEncodingForMysqlCharset(defaultMetadataCharsetMysql) : "UTF-8"; + this.errorMessageEncoding = "UTF-8"; + + } else { + String resultsCharsetName = getMysqlCharsetForJavaEncoding(characterSetResultsValue.toUpperCase(Locale.ENGLISH), + this.serverSession.getServerVersion()); + + if (resultsCharsetName == null) { + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("Connection.7", new Object[] { characterSetResultsValue }), this.session.getExceptionInterceptor()); + } + + if (!resultsCharsetName.equalsIgnoreCase(sessionResultsCharset)) { + this.session.sendCommand(getCommandBuilder().buildComQuery(null, "SET character_set_results = " + resultsCharsetName), false, 0); + this.serverSession.getServerVariables().put(CHARACTER_SET_RESULTS, resultsCharsetName); + } + + this.metadataEncoding = characterSetResultsValue; + this.errorMessageEncoding = characterSetResultsValue; + } + + this.metadataCollationIndex = getCollationIndexForJavaEncoding(this.metadataEncoding, this.serverSession.getServerVersion()); + + checkForCharsetMismatch(); + + /** + * Check if we need a CharsetEncoder for escaping codepoints that are + * transformed to backslash (0x5c) in the connection encoding. + */ + try { + CharsetEncoder enc = Charset.forName(this.characterEncoding.getValue()).newEncoder(); + CharBuffer cbuf = CharBuffer.allocate(1); + ByteBuffer bbuf = ByteBuffer.allocate(1); + + cbuf.put("\u00a5"); + cbuf.position(0); + enc.encode(cbuf, bbuf, true); + if (bbuf.get(0) == '\\') { + this.requiresEscapingEncoder = true; + } else { + cbuf.clear(); + bbuf.clear(); + + cbuf.put("\u20a9"); + cbuf.position(0); + enc.encode(cbuf, bbuf, true); + if (bbuf.get(0) == '\\') { + this.requiresEscapingEncoder = true; + } + } + } catch (java.nio.charset.UnsupportedCharsetException ucex) { + // fallback to String API + byte bbuf[] = StringUtils.getBytes("\u00a5", this.characterEncoding.getValue()); + if (bbuf[0] == '\\') { + this.requiresEscapingEncoder = true; + } else { + bbuf = StringUtils.getBytes("\u20a9", this.characterEncoding.getValue()); + if (bbuf[0] == '\\') { + this.requiresEscapingEncoder = true; + } + } + } + } + + private boolean characterSetNamesMatches(String mysqlEncodingName) { + // set names is equivalent to character_set_client ..._results and ..._connection, but we set _results later, so don't check it here. + return (mysqlEncodingName != null && mysqlEncodingName.equalsIgnoreCase(this.serverSession.getServerVariable(CHARACTER_SET_CLIENT)) + && mysqlEncodingName.equalsIgnoreCase(this.serverSession.getServerVariable(CHARACTER_SET_CONNECTION))); + } + + /** + * Get the server's default character set name according to collation index from server greeting, + * or value of 'character_set_server' variable if there is no mapping for that index + * + * @return MySQL charset name + */ + public String getServerDefaultCharset() { + String charset = getStaticMysqlCharsetNameForCollationIndex(this.sessionCollationIndex); + return charset != null ? charset : this.serverSession.getServerVariable("character_set_server"); + } + + @Override + public String getErrorMessageEncoding() { + return this.errorMessageEncoding; + } + + @Override + public String getMetadataEncoding() { + return this.metadataEncoding; + } + + @Override + public int getMetadataCollationIndex() { + return this.metadataCollationIndex; + } + + @Override + public boolean getRequiresEscapingEncoder() { + return this.requiresEscapingEncoder; + } + + @Override + public String getPasswordCharacterEncoding() { + return getStaticJavaEncodingForCollationIndex(this.sessionCollationIndex); + } + + /** + * Builds the map needed for 4.1.0 and newer servers that maps field-level + * charset/collation info to a java character encoding name. + */ + private void buildCollationMapping() { + + Map customCollationIndexToCollationName = null; + Map customCollationNameToCollationIndex = null; + Map customCollationIndexToCharsetName = null; + Map customCharsetNameToMblen = null; + Map customCharsetNameToJavaEncoding = new HashMap<>(); + Map customJavaEncodingUcToCharsetName = new HashMap<>(); + Map customCharsetNameToCollationIndex = new HashMap<>(); + Set customMultibyteEncodings = new HashSet<>(); + + String databaseURL = this.session.getHostInfo().getDatabaseUrl(); + + if (this.cacheServerConfiguration.getValue()) { + synchronized (customCollationIndexToCharsetNameByUrl) { + customCollationIndexToCollationName = customCollationIndexToCollationNameByUrl.get(databaseURL); + customCollationNameToCollationIndex = customCollationNameToCollationIndexByUrl.get(databaseURL); + customCollationIndexToCharsetName = customCollationIndexToCharsetNameByUrl.get(databaseURL); + customCharsetNameToMblen = customCharsetNameToMblenByUrl.get(databaseURL); + customCharsetNameToJavaEncoding = customCharsetNameToJavaEncodingByUrl.get(databaseURL); + customJavaEncodingUcToCharsetName = customJavaEncodingUcToCharsetNameByUrl.get(databaseURL); + customCharsetNameToCollationIndex = customCharsetNameToCollationIndexByUrl.get(databaseURL); + customMultibyteEncodings = customMultibyteEncodingsByUrl.get(databaseURL); + } + } + + if (customCollationIndexToCharsetName == null && this.session.getPropertySet().getBooleanProperty(PropertyKey.detectCustomCollations).getValue()) { + customCollationIndexToCollationName = new HashMap<>(); + customCollationNameToCollationIndex = new HashMap<>(); + customCollationIndexToCharsetName = new HashMap<>(); + customCharsetNameToMblen = new HashMap<>(); + + String customCharsetMapping = this.session.getPropertySet().getStringProperty(PropertyKey.customCharsetMapping).getValue(); + if (customCharsetMapping != null) { + String[] pairs = customCharsetMapping.split(","); + for (String pair : pairs) { + int keyEnd = pair.indexOf(":"); + if (keyEnd > 0 && (keyEnd + 1) < pair.length()) { + String charset = pair.substring(0, keyEnd); + String encoding = pair.substring(keyEnd + 1); + customCharsetNameToJavaEncoding.put(charset, encoding); + customJavaEncodingUcToCharsetName.put(encoding.toUpperCase(Locale.ENGLISH), charset); + } + } + } + + ValueFactory ivf = new IntegerValueFactory(this.session.getPropertySet()); + + try { + NativePacketPayload resultPacket = this.session.sendCommand(getCommandBuilder().buildComQuery(null, + "select c.COLLATION_NAME, c.CHARACTER_SET_NAME, c.ID, cs.MAXLEN, c.IS_DEFAULT='Yes' from INFORMATION_SCHEMA.COLLATIONS as c left join" + + " INFORMATION_SCHEMA.CHARACTER_SETS as cs on cs.CHARACTER_SET_NAME=c.CHARACTER_SET_NAME"), + false, 0); + Resultset rs = this.session.getProtocol().readAllResults(-1, false, resultPacket, false, null, new ResultsetFactory(Type.FORWARD_ONLY, null)); + ValueFactory svf = new StringValueFactory(this.session.getPropertySet()); + Row r; + while ((r = rs.getRows().next()) != null) { + String collationName = r.getValue(0, svf); + String charsetName = r.getValue(1, svf); + int collationIndex = ((Number) r.getValue(2, ivf)).intValue(); + int maxlen = ((Number) r.getValue(3, ivf)).intValue(); + boolean isDefault = ((Number) r.getValue(4, ivf)).intValue() > 0; + + if (collationIndex >= MAP_SIZE // + || !collationName.equals(getStaticCollationNameForCollationIndex(collationIndex)) + || !charsetName.equals(getStaticMysqlCharsetNameForCollationIndex(collationIndex))) { + customCollationIndexToCollationName.put(collationIndex, collationName); + customCollationNameToCollationIndex.put(collationName, collationIndex); + customCollationIndexToCharsetName.put(collationIndex, charsetName); + if (isDefault) { + customCharsetNameToCollationIndex.put(charsetName, collationIndex); + } else { + customCharsetNameToCollationIndex.putIfAbsent(charsetName, collationIndex); + } + + } + + // if no static map for charsetName adding to custom map + if (getStaticMysqlCharsetByName(charsetName) == null) { + customCharsetNameToMblen.put(charsetName, maxlen); + if (maxlen > 1) { + String enc = customCharsetNameToJavaEncoding.get(charsetName); + if (enc != null) { + customMultibyteEncodings.add(enc.toUpperCase(Locale.ENGLISH)); + } + } + } + + } + } catch (IOException e) { + throw ExceptionFactory.createException(e.getMessage(), e, this.session.getExceptionInterceptor()); + } + + if (this.cacheServerConfiguration.getValue()) { + synchronized (customCollationIndexToCharsetNameByUrl) { + customCollationIndexToCollationNameByUrl.put(databaseURL, Collections.unmodifiableMap(customCollationIndexToCollationName)); + customCollationNameToCollationIndexByUrl.put(databaseURL, Collections.unmodifiableMap(customCollationNameToCollationIndex)); + customCollationIndexToCharsetNameByUrl.put(databaseURL, Collections.unmodifiableMap(customCollationIndexToCharsetName)); + customCharsetNameToMblenByUrl.put(databaseURL, Collections.unmodifiableMap(customCharsetNameToMblen)); + customCharsetNameToJavaEncodingByUrl.put(databaseURL, Collections.unmodifiableMap(customCharsetNameToJavaEncoding)); + customJavaEncodingUcToCharsetNameByUrl.put(databaseURL, Collections.unmodifiableMap(customJavaEncodingUcToCharsetName)); + customCharsetNameToCollationIndexByUrl.put(databaseURL, Collections.unmodifiableMap(customCharsetNameToCollationIndex)); + customMultibyteEncodingsByUrl.put(databaseURL, Collections.unmodifiableSet(customMultibyteEncodings)); + } + } + } + + if (customCollationIndexToCharsetName != null) { + this.collationIndexToCollationName = customCollationIndexToCollationName; + this.collationNameToCollationIndex = customCollationNameToCollationIndex; + this.collationIndexToCharsetName = customCollationIndexToCharsetName; + this.charsetNameToMblen = customCharsetNameToMblen; + this.charsetNameToJavaEncoding = customCharsetNameToJavaEncoding; + this.javaEncodingUcToCharsetName = customJavaEncodingUcToCharsetName; + this.charsetNameToCollationIndex = customCharsetNameToCollationIndex; + this.multibyteEncodings = customMultibyteEncodings; + } + } + + @Override + public Integer getCollationIndexForCollationName(String collationName) { + Integer collationIndex = null; + if (this.collationNameToCollationIndex == null || (collationIndex = this.collationNameToCollationIndex.get(collationName)) == null) { + collationIndex = getStaticCollationIndexForCollationName(collationName); + } + return collationIndex; + } + + @Override + public String getCollationNameForCollationIndex(Integer collationIndex) { + String collationName = null; + if (collationIndex != null + && (this.collationIndexToCollationName == null || (collationName = this.collationIndexToCollationName.get(collationIndex)) == null)) { + collationName = getStaticCollationNameForCollationIndex(collationIndex); + } + return collationName; + } + + @Override + public String getMysqlCharsetNameForCollationIndex(Integer collationIndex) { + String charset = null; + if (this.collationIndexToCharsetName == null || (charset = this.collationIndexToCharsetName.get(collationIndex)) == null) { + charset = getStaticMysqlCharsetNameForCollationIndex(collationIndex); + } + return charset; + } + + @Override + public String getJavaEncodingForCollationIndex(int collationIndex) { + return getJavaEncodingForCollationIndex(collationIndex, this.characterEncoding.getValue()); + } + + public String getJavaEncodingForCollationIndex(Integer collationIndex, String fallBackJavaEncoding) { + String encoding = null; + String charset = null; + if (collationIndex != NativeConstants.NO_CHARSET_INFO) { + if (this.collationIndexToCharsetName != null && (charset = this.collationIndexToCharsetName.get(collationIndex)) != null) { + encoding = getJavaEncodingForMysqlCharset(charset, fallBackJavaEncoding); + } + if (encoding == null) { + encoding = getStaticJavaEncodingForCollationIndex(collationIndex, fallBackJavaEncoding); + } + } + return encoding != null ? encoding : fallBackJavaEncoding; + } + + public int getCollationIndexForJavaEncoding(String javaEncoding, ServerVersion version) { + return getCollationIndexForMysqlCharsetName(getMysqlCharsetForJavaEncoding(javaEncoding, version)); + } + + public int getCollationIndexForMysqlCharsetName(String charsetName) { + Integer index = null; + if (this.charsetNameToCollationIndex == null || (index = this.charsetNameToCollationIndex.get(charsetName)) == null) { + index = getStaticCollationIndexForMysqlCharsetName(charsetName); + } + return index; + } + + public String getJavaEncodingForMysqlCharset(String mysqlCharsetName) { + String encoding = null; + if (this.charsetNameToJavaEncoding == null || (encoding = this.charsetNameToJavaEncoding.get(mysqlCharsetName)) == null) { + encoding = getStaticJavaEncodingForMysqlCharset(mysqlCharsetName); + } + return encoding; + } + + public String getJavaEncodingForMysqlCharset(String mysqlCharsetName, String javaEncoding) { + String encoding = null; + if (this.charsetNameToJavaEncoding == null || (encoding = this.charsetNameToJavaEncoding.get(mysqlCharsetName)) == null) { + encoding = getStaticJavaEncodingForMysqlCharset(mysqlCharsetName, javaEncoding); + } + return encoding; + } + + public String getMysqlCharsetForJavaEncoding(String javaEncoding, ServerVersion version) { + String charset = null; + if (this.javaEncodingUcToCharsetName == null || (charset = this.javaEncodingUcToCharsetName.get(javaEncoding.toUpperCase(Locale.ENGLISH))) == null) { + charset = getStaticMysqlCharsetForJavaEncoding(javaEncoding, version); + } + return charset; + } + + public boolean isImpermissibleCollation(int collationIndex) { + String charsetName = null; + if (this.collationIndexToCharsetName != null && (charsetName = this.collationIndexToCharsetName.get(collationIndex)) != null) { + if (charsetName.equals(MYSQL_CHARSET_NAME_ucs2) || charsetName.equals(MYSQL_CHARSET_NAME_utf16) || charsetName.equals(MYSQL_CHARSET_NAME_utf16le) + || charsetName.equals(MYSQL_CHARSET_NAME_utf32)) { + return true; + } + } + return isStaticImpermissibleCollation(collationIndex); + } + + public boolean isMultibyteCharset(String javaEncodingName) { + if (this.multibyteEncodings != null && this.multibyteEncodings.contains(javaEncodingName.toUpperCase(Locale.ENGLISH))) { + return true; + } + return isStaticMultibyteCharset(javaEncodingName); + } + + @Override + public int getMaxBytesPerChar(String javaCharsetName) { + return getMaxBytesPerChar(null, javaCharsetName); + } + + @Override + public int getMaxBytesPerChar(Integer charsetIndex, String javaCharsetName) { + String charset = null; + if ((charset = getMysqlCharsetNameForCollationIndex(charsetIndex)) == null) { + // if we didn't find charset name by index + charset = getStaticMysqlCharsetForJavaEncoding(javaCharsetName, this.serverSession.getServerVersion()); + } + Integer mblen = null; + if (this.charsetNameToMblen == null || (mblen = this.charsetNameToMblen.get(charset)) == null) { + mblen = getStaticMblen(charset); + } + return mblen != null ? mblen.intValue() : 1; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/NativeQueryAttributesBindValue.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/NativeQueryAttributesBindValue.java new file mode 100644 index 0000000..3656c1a --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/NativeQueryAttributesBindValue.java @@ -0,0 +1,164 @@ +/* + * Copyright (c) 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.time.Duration; +import java.time.Instant; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.OffsetDateTime; +import java.time.OffsetTime; +import java.time.ZonedDateTime; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; + +import com.mysql.cj.protocol.a.NativeConstants; + +public class NativeQueryAttributesBindValue implements QueryAttributesBindValue { + private static final Map, Integer> JAVA_TO_MYSQL_FIELD_TYPE = new HashMap<>(); + static { + JAVA_TO_MYSQL_FIELD_TYPE.put(String.class, MysqlType.FIELD_TYPE_STRING); + JAVA_TO_MYSQL_FIELD_TYPE.put(Boolean.class, MysqlType.FIELD_TYPE_TINY); + JAVA_TO_MYSQL_FIELD_TYPE.put(Byte.class, MysqlType.FIELD_TYPE_TINY); + JAVA_TO_MYSQL_FIELD_TYPE.put(Short.class, MysqlType.FIELD_TYPE_SHORT); + JAVA_TO_MYSQL_FIELD_TYPE.put(Integer.class, MysqlType.FIELD_TYPE_LONG); + JAVA_TO_MYSQL_FIELD_TYPE.put(Long.class, MysqlType.FIELD_TYPE_LONGLONG); + JAVA_TO_MYSQL_FIELD_TYPE.put(BigInteger.class, MysqlType.FIELD_TYPE_LONGLONG); + JAVA_TO_MYSQL_FIELD_TYPE.put(Float.class, MysqlType.FIELD_TYPE_FLOAT); + JAVA_TO_MYSQL_FIELD_TYPE.put(Double.class, MysqlType.FIELD_TYPE_DOUBLE); + JAVA_TO_MYSQL_FIELD_TYPE.put(BigDecimal.class, MysqlType.FIELD_TYPE_DOUBLE); + JAVA_TO_MYSQL_FIELD_TYPE.put(java.sql.Date.class, MysqlType.FIELD_TYPE_DATE); + JAVA_TO_MYSQL_FIELD_TYPE.put(LocalDate.class, MysqlType.FIELD_TYPE_DATE); + JAVA_TO_MYSQL_FIELD_TYPE.put(java.sql.Time.class, MysqlType.FIELD_TYPE_TIME); + JAVA_TO_MYSQL_FIELD_TYPE.put(LocalTime.class, MysqlType.FIELD_TYPE_TIME); + JAVA_TO_MYSQL_FIELD_TYPE.put(OffsetTime.class, MysqlType.FIELD_TYPE_TIME); + JAVA_TO_MYSQL_FIELD_TYPE.put(Duration.class, MysqlType.FIELD_TYPE_TIME); + JAVA_TO_MYSQL_FIELD_TYPE.put(LocalDateTime.class, MysqlType.FIELD_TYPE_DATETIME); + JAVA_TO_MYSQL_FIELD_TYPE.put(java.sql.Timestamp.class, MysqlType.FIELD_TYPE_TIMESTAMP); + JAVA_TO_MYSQL_FIELD_TYPE.put(Instant.class, MysqlType.FIELD_TYPE_TIMESTAMP); + JAVA_TO_MYSQL_FIELD_TYPE.put(OffsetDateTime.class, MysqlType.FIELD_TYPE_TIMESTAMP); + JAVA_TO_MYSQL_FIELD_TYPE.put(ZonedDateTime.class, MysqlType.FIELD_TYPE_TIMESTAMP); + JAVA_TO_MYSQL_FIELD_TYPE.put(java.util.Date.class, MysqlType.FIELD_TYPE_TIMESTAMP); + JAVA_TO_MYSQL_FIELD_TYPE.put(java.util.Calendar.class, MysqlType.FIELD_TYPE_TIMESTAMP); + } + + /** The attribute name */ + private String name; + + /** The attribute value */ + public Object value; + + /** The attribute MySQL type */ + protected int type = MysqlType.FIELD_TYPE_NULL; + + protected NativeQueryAttributesBindValue(String name, Object value) { + this.name = name; + this.value = value; + this.type = getMysqlFieldType(value); + } + + private int getMysqlFieldType(Object obj) { + if (obj == null) { + return MysqlType.FIELD_TYPE_NULL; + } + + Integer mysqlFieldType = JAVA_TO_MYSQL_FIELD_TYPE.get(obj.getClass()); + if (mysqlFieldType != null) { + return mysqlFieldType; + } + + Optional mysqlType = JAVA_TO_MYSQL_FIELD_TYPE.entrySet().stream().filter(m -> m.getKey().isAssignableFrom(obj.getClass())) + .map(m -> m.getValue()).findFirst(); + if (mysqlType.isPresent()) { + return mysqlType.get(); + } + + // Fall-back to String. + return MysqlType.FIELD_TYPE_STRING; + } + + @Override + public boolean isNull() { + return this.type == MysqlType.FIELD_TYPE_NULL; + } + + @Override + public String getName() { + return this.name; + } + + @Override + public int getType() { + return this.type; + } + + @Override + public Object getValue() { + return this.value; + } + + @Override + public long getBoundLength() { + if (isNull()) { + return 0; + } + + switch (this.type) { + case MysqlType.FIELD_TYPE_TINY: + return NativeConstants.BIN_LEN_INT1; + case MysqlType.FIELD_TYPE_SHORT: + return NativeConstants.BIN_LEN_INT2; + case MysqlType.FIELD_TYPE_LONG: + return NativeConstants.BIN_LEN_INT4; + case MysqlType.FIELD_TYPE_LONGLONG: + return NativeConstants.BIN_LEN_INT8; + case MysqlType.FIELD_TYPE_FLOAT: + return NativeConstants.BIN_LEN_FLOAT; + case MysqlType.FIELD_TYPE_DOUBLE: + return NativeConstants.BIN_LEN_DOUBLE; + case MysqlType.FIELD_TYPE_DATE: + return NativeConstants.BIN_LEN_DATE + 1; + case MysqlType.FIELD_TYPE_TIME: + return NativeConstants.BIN_LEN_TIME_WITH_MICROS + 1; + case MysqlType.FIELD_TYPE_DATETIME: + return NativeConstants.BIN_LEN_TIMESTAMP_WITH_MICROS + 1; + case MysqlType.FIELD_TYPE_TIMESTAMP: + return NativeConstants.BIN_LEN_TIMESTAMP_WITH_TZ + 1; + case MysqlType.FIELD_TYPE_STRING: + return this.value.toString().length() + 9; + default: + return 0; + } + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/NativeQueryAttributesBindings.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/NativeQueryAttributesBindings.java new file mode 100644 index 0000000..3b31361 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/NativeQueryAttributesBindings.java @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.util.ArrayList; +import java.util.List; +import java.util.function.Consumer; + +public class NativeQueryAttributesBindings implements QueryAttributesBindings { + private List bindAttributes = new ArrayList<>(); + + public NativeQueryAttributesBindings() { + } + + @Override + public void setAttribute(String name, Object value) { + this.bindAttributes.add(new NativeQueryAttributesBindValue(name, value)); + } + + @Override + public int getCount() { + return this.bindAttributes.size(); + } + + @Override + public QueryAttributesBindValue getAttributeValue(int index) { + return this.bindAttributes.get(index); + } + + @Override + public void runThroughAll(Consumer bindAttribute) { + this.bindAttributes.forEach(bindAttribute::accept); + } + + @Override + public void clearAttributes() { + this.bindAttributes.clear(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/NativeSession.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/NativeSession.java new file mode 100644 index 0000000..7f82da0 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/NativeSession.java @@ -0,0 +1,831 @@ +/* + * Copyright (c) 2015, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.io.IOException; +import java.io.InputStream; +import java.io.Serializable; +import java.lang.ref.WeakReference; +import java.net.SocketAddress; +import java.sql.SQLException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Properties; +import java.util.Timer; +import java.util.concurrent.CopyOnWriteArrayList; +import java.util.function.Supplier; + +import com.mysql.cj.conf.HostInfo; +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.conf.RuntimeProperty; +import com.mysql.cj.exceptions.CJCommunicationsException; +import com.mysql.cj.exceptions.CJException; +import com.mysql.cj.exceptions.ConnectionIsClosedException; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.ExceptionInterceptor; +import com.mysql.cj.exceptions.ExceptionInterceptorChain; +import com.mysql.cj.exceptions.MysqlErrorNumbers; +import com.mysql.cj.exceptions.OperationCancelledException; +import com.mysql.cj.interceptors.QueryInterceptor; +import com.mysql.cj.log.Log; +import com.mysql.cj.protocol.ColumnDefinition; +import com.mysql.cj.protocol.NetworkResources; +import com.mysql.cj.protocol.ProtocolEntityFactory; +import com.mysql.cj.protocol.Resultset; +import com.mysql.cj.protocol.Resultset.Type; +import com.mysql.cj.protocol.SocketConnection; +import com.mysql.cj.protocol.SocketFactory; +import com.mysql.cj.protocol.a.NativeMessageBuilder; +import com.mysql.cj.protocol.a.NativePacketPayload; +import com.mysql.cj.protocol.a.NativeProtocol; +import com.mysql.cj.protocol.a.NativeServerSession; +import com.mysql.cj.protocol.a.NativeSocketConnection; +import com.mysql.cj.protocol.a.ResultsetFactory; +import com.mysql.cj.result.Field; +import com.mysql.cj.result.LongValueFactory; +import com.mysql.cj.result.Row; +import com.mysql.cj.result.StringValueFactory; +import com.mysql.cj.result.ValueFactory; +import com.mysql.cj.util.StringUtils; + +public class NativeSession extends CoreSession implements Serializable { + + private static final long serialVersionUID = 5323638898749073419L; + + private CacheAdapter> serverConfigCache; + + /** When did the last query finish? */ + private long lastQueryFinishedTime = 0; + + /** Does this connection need to be tested? */ + private boolean needsPing = false; + + private NativeMessageBuilder commandBuilder = null; + + /** Has this session been closed? */ + private boolean isClosed = true; + + /** Why was this session implicitly closed, if known? (for diagnostics) */ + private Throwable forceClosedReason; + + private CopyOnWriteArrayList> listeners = new CopyOnWriteArrayList<>(); + + private transient Timer cancelTimer; + + public NativeSession(HostInfo hostInfo, PropertySet propSet) { + super(hostInfo, propSet); + } + + public void connect(HostInfo hi, String user, String password, String database, int loginTimeout, TransactionEventHandler transactionManager) + throws IOException { + + this.hostInfo = hi; + + // reset max-rows to default value + this.setSessionMaxRows(-1); + + // TODO do we need different types of physical connections? + SocketConnection socketConnection = new NativeSocketConnection(); + socketConnection.connect(this.hostInfo.getHost(), this.hostInfo.getPort(), this.propertySet, getExceptionInterceptor(), this.log, loginTimeout); + + // we use physical connection to create a -> protocol + // this configuration places no knowledge of protocol or session on physical connection. + // physical connection is responsible *only* for I/O streams + if (this.protocol == null) { + this.protocol = NativeProtocol.getInstance(this, socketConnection, this.propertySet, this.log, transactionManager); + } else { + this.protocol.init(this, socketConnection, this.propertySet, transactionManager); + } + + // use protocol to create a -> session + // protocol is responsible for building a session and authenticating (using AuthenticationProvider) internally + this.protocol.connect(user, password, database); + + this.isClosed = false; + + this.commandBuilder = new NativeMessageBuilder(this.getServerSession().supportsQueryAttributes()); + } + + // TODO: this method should not be used in user-level APIs + public NativeProtocol getProtocol() { + return (NativeProtocol) this.protocol; + } + + @Override + public void quit() { + if (this.protocol != null) { + try { + ((NativeProtocol) this.protocol).quit(); + } catch (Exception e) { + } + + } + synchronized (this) { + if (this.cancelTimer != null) { + this.cancelTimer.cancel(); + this.cancelTimer = null; + } + } + this.isClosed = true; + super.quit(); + } + + // TODO: we should examine the call flow here, we shouldn't have to know about the socket connection but this should be address in a wider scope. + @Override + public void forceClose() { + if (this.protocol != null) { + // checking this.protocol != null isn't enough if connection is used concurrently (the usual situation + // with application servers which have additional thread management), this.protocol can become null + // at any moment after this check, causing a race condition and NPEs on next calls; + // but we may ignore them because at this stage null this.protocol means that we successfully closed all resources by other thread. + try { + this.protocol.getSocketConnection().forceClose(); + ((NativeProtocol) this.protocol).releaseResources(); + } catch (Throwable t) { + // can't do anything about it, and we're forcibly aborting + } + //this.protocol = null; // TODO actually we shouldn't remove protocol instance because some it's methods can be called after closing socket + } + synchronized (this) { + if (this.cancelTimer != null) { + this.cancelTimer.cancel(); + this.cancelTimer = null; + } + } + this.isClosed = true; + super.forceClose(); + } + + public void enableMultiQueries() { + sendCommand(this.commandBuilder.buildComSetOption(((NativeProtocol) this.protocol).getSharedSendPacket(), 0), false, 0); + ((NativeServerSession) getServerSession()).preserveOldTransactionState(); + } + + public void disableMultiQueries() { + sendCommand(this.commandBuilder.buildComSetOption(((NativeProtocol) this.protocol).getSharedSendPacket(), 1), false, 0); + ((NativeServerSession) getServerSession()).preserveOldTransactionState(); + } + + @Override + public boolean isSetNeededForAutoCommitMode(boolean autoCommitFlag) { + // Server Bug#66884 (SERVER_STATUS is always initiated with SERVER_STATUS_AUTOCOMMIT=1) invalidates "elideSetAutoCommits" feature. + // TODO Turn this feature back on as soon as the server bug is fixed. Consider making it version specific. + //return this.protocol.getServerSession().isSetNeededForAutoCommitMode(autoCommitFlag, + // getPropertySet().getBooleanReadableProperty(PropertyKey.elideSetAutoCommits).getValue()); + return ((NativeServerSession) this.protocol.getServerSession()).isSetNeededForAutoCommitMode(autoCommitFlag, false); + } + + public int getSessionMaxRows() { + return this.sessionMaxRows; + } + + public void setSessionMaxRows(int sessionMaxRows) { + this.sessionMaxRows = sessionMaxRows; + } + + public void setQueryInterceptors(List queryInterceptors) { + ((NativeProtocol) this.protocol).setQueryInterceptors(queryInterceptors); + } + + public boolean isServerLocal(Session sess) { + SocketFactory factory = this.protocol.getSocketConnection().getSocketFactory(); + return factory.isLocallyConnected(sess); + } + + /** + * Used by MiniAdmin to shutdown a MySQL server + * + */ + public void shutdownServer() { + if (versionMeetsMinimum(5, 7, 9)) { + sendCommand(this.commandBuilder.buildComQuery(getSharedSendPacket(), "SHUTDOWN"), false, 0); + } else { + sendCommand(this.commandBuilder.buildComShutdown(getSharedSendPacket()), false, 0); + } + } + + public void setSocketTimeout(int milliseconds) { + getPropertySet().getProperty(PropertyKey.socketTimeout).setValue(milliseconds); // for re-connects + ((NativeProtocol) this.protocol).setSocketTimeout(milliseconds); + } + + public int getSocketTimeout() { + RuntimeProperty sto = getPropertySet().getProperty(PropertyKey.socketTimeout); + return sto.getValue(); + } + + /** + * Returns the packet used for sending data (used by PreparedStatement) with position set to 0. + * Guarded by external synchronization on a mutex. + * + * @return A packet to send data with + */ + public NativePacketPayload getSharedSendPacket() { + return ((NativeProtocol) this.protocol).getSharedSendPacket(); + } + + public void dumpPacketRingBuffer() { + ((NativeProtocol) this.protocol).dumpPacketRingBuffer(); + } + + public T invokeQueryInterceptorsPre(Supplier sql, Query interceptedQuery, boolean forceExecute) { + return ((NativeProtocol) this.protocol).invokeQueryInterceptorsPre(sql, interceptedQuery, forceExecute); + } + + public T invokeQueryInterceptorsPost(Supplier sql, Query interceptedQuery, T originalResultSet, boolean forceExecute) { + return ((NativeProtocol) this.protocol).invokeQueryInterceptorsPost(sql, interceptedQuery, originalResultSet, forceExecute); + } + + public boolean shouldIntercept() { + return ((NativeProtocol) this.protocol).getQueryInterceptors() != null; + } + + public long getCurrentTimeNanosOrMillis() { + return ((NativeProtocol) this.protocol).getCurrentTimeNanosOrMillis(); + } + + public final NativePacketPayload sendCommand(NativePacketPayload queryPacket, boolean skipCheck, int timeoutMillis) { + return (NativePacketPayload) this.protocol.sendCommand(queryPacket, skipCheck, timeoutMillis); + } + + public long getSlowQueryThreshold() { + return ((NativeProtocol) this.protocol).getSlowQueryThreshold(); + } + + public boolean hadWarnings() { + return ((NativeProtocol) this.protocol).hadWarnings(); + } + + public void clearInputStream() { + ((NativeProtocol) this.protocol).clearInputStream(); + } + + public NetworkResources getNetworkResources() { + return this.protocol.getSocketConnection().getNetworkResources(); + } + + @Override + public boolean isSSLEstablished() { + return this.protocol.getSocketConnection().isSSLEstablished(); + } + + public int getCommandCount() { + return ((NativeProtocol) this.protocol).getCommandCount(); + } + + @Override + public SocketAddress getRemoteSocketAddress() { + try { + return this.protocol.getSocketConnection().getMysqlSocket().getRemoteSocketAddress(); + } catch (IOException e) { + throw new CJCommunicationsException(e); + } + } + + public InputStream getLocalInfileInputStream() { + return this.protocol.getLocalInfileInputStream(); + } + + public void setLocalInfileInputStream(InputStream stream) { + this.protocol.setLocalInfileInputStream(stream); + } + + private void createConfigCacheIfNeeded(Object syncMutex) { + synchronized (syncMutex) { + if (this.serverConfigCache != null) { + return; + } + + try { + Class factoryClass; + + factoryClass = Class.forName(getPropertySet().getStringProperty(PropertyKey.serverConfigCacheFactory).getStringValue()); + + @SuppressWarnings("unchecked") + CacheAdapterFactory> cacheFactory = ((CacheAdapterFactory>) factoryClass.newInstance()); + + this.serverConfigCache = cacheFactory.getInstance(syncMutex, this.hostInfo.getDatabaseUrl(), Integer.MAX_VALUE, Integer.MAX_VALUE); + + ExceptionInterceptor evictOnCommsError = new ExceptionInterceptor() { + + public ExceptionInterceptor init(Properties config, Log log1) { + return this; + } + + public void destroy() { + } + + @SuppressWarnings("synthetic-access") + public Exception interceptException(Exception sqlEx) { + if (sqlEx instanceof SQLException && ((SQLException) sqlEx).getSQLState() != null + && ((SQLException) sqlEx).getSQLState().startsWith("08")) { + NativeSession.this.serverConfigCache.invalidate(NativeSession.this.hostInfo.getDatabaseUrl()); + } + return null; + } + }; + + if (this.exceptionInterceptor == null) { + this.exceptionInterceptor = evictOnCommsError; + } else { + ((ExceptionInterceptorChain) this.exceptionInterceptor).addRingZero(evictOnCommsError); + } + } catch (ClassNotFoundException e) { + throw ExceptionFactory.createException(Messages.getString("Connection.CantFindCacheFactory", + new Object[] { getPropertySet().getStringProperty(PropertyKey.parseInfoCacheFactory).getValue(), PropertyKey.parseInfoCacheFactory }), + e, getExceptionInterceptor()); + } catch (InstantiationException | IllegalAccessException | CJException e) { + throw ExceptionFactory.createException(Messages.getString("Connection.CantLoadCacheFactory", + new Object[] { getPropertySet().getStringProperty(PropertyKey.parseInfoCacheFactory).getValue(), PropertyKey.parseInfoCacheFactory }), + e, getExceptionInterceptor()); + } + } + } + + // TODO what's the purpose of this variable? + private final static String SERVER_VERSION_STRING_VAR_NAME = "server_version_string"; + + /** + * Loads the result of 'SHOW VARIABLES' into the serverVariables field so + * that the driver can configure itself. + * + * @param syncMutex + * synchronization mutex + * @param version + * driver version string + */ + public void loadServerVariables(Object syncMutex, String version) { + + if (this.cacheServerConfiguration.getValue()) { + createConfigCacheIfNeeded(syncMutex); + + Map cachedVariableMap = this.serverConfigCache.get(this.hostInfo.getDatabaseUrl()); + + if (cachedVariableMap != null) { + String cachedServerVersion = cachedVariableMap.get(SERVER_VERSION_STRING_VAR_NAME); + + if (cachedServerVersion != null && getServerSession().getServerVersion() != null + && cachedServerVersion.equals(getServerSession().getServerVersion().toString())) { + this.protocol.getServerSession().setServerVariables(cachedVariableMap); + + return; + } + + this.serverConfigCache.invalidate(this.hostInfo.getDatabaseUrl()); + } + } + + try { + if (version != null && version.indexOf('*') != -1) { + StringBuilder buf = new StringBuilder(version.length() + 10); + for (int i = 0; i < version.length(); i++) { + char c = version.charAt(i); + buf.append(c == '*' ? "[star]" : c); + } + version = buf.toString(); + } + + String versionComment = (this.propertySet.getBooleanProperty(PropertyKey.paranoid).getValue() || version == null) ? "" : "/* " + version + " */"; + + this.protocol.getServerSession().setServerVariables(new HashMap()); + + if (versionMeetsMinimum(5, 1, 0)) { + StringBuilder queryBuf = new StringBuilder(versionComment).append("SELECT"); + queryBuf.append(" @@session.auto_increment_increment AS auto_increment_increment"); + queryBuf.append(", @@character_set_client AS character_set_client"); + queryBuf.append(", @@character_set_connection AS character_set_connection"); + queryBuf.append(", @@character_set_results AS character_set_results"); + queryBuf.append(", @@character_set_server AS character_set_server"); + queryBuf.append(", @@collation_server AS collation_server"); + queryBuf.append(", @@collation_connection AS collation_connection"); + queryBuf.append(", @@init_connect AS init_connect"); + queryBuf.append(", @@interactive_timeout AS interactive_timeout"); + if (!versionMeetsMinimum(5, 5, 0)) { + queryBuf.append(", @@language AS language"); + } + queryBuf.append(", @@license AS license"); + queryBuf.append(", @@lower_case_table_names AS lower_case_table_names"); + queryBuf.append(", @@max_allowed_packet AS max_allowed_packet"); + queryBuf.append(", @@net_write_timeout AS net_write_timeout"); + queryBuf.append(", @@performance_schema AS performance_schema"); + if (!versionMeetsMinimum(8, 0, 3)) { + queryBuf.append(", @@query_cache_size AS query_cache_size"); + queryBuf.append(", @@query_cache_type AS query_cache_type"); + } + queryBuf.append(", @@sql_mode AS sql_mode"); + queryBuf.append(", @@system_time_zone AS system_time_zone"); + queryBuf.append(", @@time_zone AS time_zone"); + if (versionMeetsMinimum(8, 0, 3) || (versionMeetsMinimum(5, 7, 20) && !versionMeetsMinimum(8, 0, 0))) { + queryBuf.append(", @@transaction_isolation AS transaction_isolation"); + } else { + queryBuf.append(", @@tx_isolation AS transaction_isolation"); + } + queryBuf.append(", @@wait_timeout AS wait_timeout"); + + NativePacketPayload resultPacket = sendCommand(this.commandBuilder.buildComQuery(null, queryBuf.toString()), false, 0); + Resultset rs = ((NativeProtocol) this.protocol).readAllResults(-1, false, resultPacket, false, null, + new ResultsetFactory(Type.FORWARD_ONLY, null)); + Field[] f = rs.getColumnDefinition().getFields(); + if (f.length > 0) { + ValueFactory vf = new StringValueFactory(this.propertySet); + Row r; + if ((r = rs.getRows().next()) != null) { + for (int i = 0; i < f.length; i++) { + String value = r.getValue(i, vf); + this.protocol.getServerSession().getServerVariables().put(f[i].getColumnLabel(), + "utf8mb3".equalsIgnoreCase(value) ? "utf8" : value); // recent server versions return "utf8mb3" instead of "utf8" + } + } + } + + } else { + NativePacketPayload resultPacket = sendCommand(this.commandBuilder.buildComQuery(null, versionComment + "SHOW VARIABLES"), false, 0); + Resultset rs = ((NativeProtocol) this.protocol).readAllResults(-1, false, resultPacket, false, null, + new ResultsetFactory(Type.FORWARD_ONLY, null)); + ValueFactory vf = new StringValueFactory(this.propertySet); + Row r; + while ((r = rs.getRows().next()) != null) { + this.protocol.getServerSession().getServerVariables().put(r.getValue(0, vf), r.getValue(1, vf)); + } + } + } catch (IOException e) { + throw ExceptionFactory.createException(e.getMessage(), e); + } + + if (this.cacheServerConfiguration.getValue()) { + this.protocol.getServerSession().getServerVariables().put(SERVER_VERSION_STRING_VAR_NAME, getServerSession().getServerVersion().toString()); + this.serverConfigCache.put(this.hostInfo.getDatabaseUrl(), this.protocol.getServerSession().getServerVariables()); + } + } + + public void setSessionVariables() { + String sessionVariables = getPropertySet().getStringProperty(PropertyKey.sessionVariables).getValue(); + if (sessionVariables != null) { + List variablesToSet = new ArrayList<>(); + for (String part : StringUtils.split(sessionVariables, ",", "\"'(", "\"')", "\"'", true)) { + variablesToSet.addAll(StringUtils.split(part, ";", "\"'(", "\"')", "\"'", true)); + } + + if (!variablesToSet.isEmpty()) { + StringBuilder query = new StringBuilder("SET "); + String separator = ""; + for (String variableToSet : variablesToSet) { + if (variableToSet.length() > 0) { + query.append(separator); + if (!variableToSet.startsWith("@")) { + query.append("SESSION "); + } + query.append(variableToSet); + separator = ","; + } + } + sendCommand(this.commandBuilder.buildComQuery(null, query.toString()), false, 0); + } + } + } + + public String getProcessHost() { + try { + long threadId = getThreadId(); + String processHost = findProcessHost(threadId); + + if (processHost == null) { + // http://bugs.mysql.com/bug.php?id=44167 - connection ids on the wire wrap at 4 bytes even though they're 64-bit numbers + this.log.logWarn(String.format( + "Connection id %d not found in \"SHOW PROCESSLIST\", assuming 32-bit overflow, using SELECT CONNECTION_ID() instead", threadId)); + + NativePacketPayload resultPacket = sendCommand(this.commandBuilder.buildComQuery(null, "SELECT CONNECTION_ID()"), false, 0); + Resultset rs = ((NativeProtocol) this.protocol).readAllResults(-1, false, resultPacket, false, null, + new ResultsetFactory(Type.FORWARD_ONLY, null)); + + ValueFactory lvf = new LongValueFactory(getPropertySet()); + Row r; + if ((r = rs.getRows().next()) != null) { + threadId = r.getValue(0, lvf); + processHost = findProcessHost(threadId); + } else { + this.log.logError("No rows returned for statement \"SELECT CONNECTION_ID()\", local connection check will most likely be incorrect"); + } + } + + if (processHost == null) { + this.log.logWarn(String.format( + "Cannot find process listing for connection %d in SHOW PROCESSLIST output, unable to determine if locally connected", threadId)); + } + return processHost; + } catch (IOException e) { + throw ExceptionFactory.createException(e.getMessage(), e); + } + } + + private String findProcessHost(long threadId) { + try { + String processHost = null; + + String ps = this.protocol.getServerSession().getServerVariable("performance_schema"); + + NativePacketPayload resultPacket = versionMeetsMinimum(5, 6, 0) // performance_schema.threads in MySQL 5.5 does not contain PROCESSLIST_HOST column + && ps != null && ("1".contentEquals(ps) || "ON".contentEquals(ps)) + ? sendCommand(this.commandBuilder.buildComQuery(null, + "select PROCESSLIST_ID, PROCESSLIST_USER, PROCESSLIST_HOST from performance_schema.threads where PROCESSLIST_ID=" + + threadId), + false, 0) + : sendCommand(this.commandBuilder.buildComQuery(null, "SHOW PROCESSLIST"), false, 0); + + Resultset rs = ((NativeProtocol) this.protocol).readAllResults(-1, false, resultPacket, false, null, new ResultsetFactory(Type.FORWARD_ONLY, null)); + + ValueFactory lvf = new LongValueFactory(getPropertySet()); + ValueFactory svf = new StringValueFactory(this.propertySet); + Row r; + while ((r = rs.getRows().next()) != null) { + long id = r.getValue(0, lvf); + if (threadId == id) { + processHost = r.getValue(2, svf); + break; + } + } + + return processHost; + + } catch (IOException e) { + throw ExceptionFactory.createException(e.getMessage(), e); + } + } + + /** + * Get the variable value from server. + * + * @param varName + * server variable name + * @return server variable value + */ + public String queryServerVariable(String varName) { + try { + + NativePacketPayload resultPacket = sendCommand(this.commandBuilder.buildComQuery(null, "SELECT " + varName), false, 0); + Resultset rs = ((NativeProtocol) this.protocol).readAllResults(-1, false, resultPacket, false, null, new ResultsetFactory(Type.FORWARD_ONLY, null)); + + ValueFactory svf = new StringValueFactory(this.propertySet); + Row r; + if ((r = rs.getRows().next()) != null) { + String s = r.getValue(0, svf); + if (s != null) { + return s; + } + } + + return null; + + } catch (IOException e) { + throw ExceptionFactory.createException(e.getMessage(), e); + } + } + + /** + * Send a query to the server. Returns one of the ResultSet objects. + * To ensure that Statement's queries are serialized, calls to this method + * should be enclosed in a connection mutex synchronized block. + * + * @param + * extends {@link Resultset} + * @param callingQuery + * {@link Query} object + * @param query + * the SQL statement to be executed + * @param maxRows + * rows limit + * @param packet + * {@link NativePacketPayload} + * @param streamResults + * whether a stream result should be created + * @param resultSetFactory + * {@link ProtocolEntityFactory} + * @param cachedMetadata + * use this metadata instead of the one provided on wire + * @param isBatch + * is it a batch query + * + * @return a ResultSet holding the results + */ + public T execSQL(Query callingQuery, String query, int maxRows, NativePacketPayload packet, boolean streamResults, + ProtocolEntityFactory resultSetFactory, ColumnDefinition cachedMetadata, boolean isBatch) { + + long queryStartTime = this.gatherPerfMetrics.getValue() ? System.currentTimeMillis() : 0; + int endOfQueryPacketPosition = packet != null ? packet.getPosition() : 0; + + this.lastQueryFinishedTime = 0; // we're busy! + + if (this.autoReconnect.getValue() && (getServerSession().isAutoCommit() || this.autoReconnectForPools.getValue()) && this.needsPing && !isBatch) { + try { + ping(false, 0); + this.needsPing = false; + + } catch (Exception Ex) { + invokeReconnectListeners(); + } + } + + try { + return packet == null + ? ((NativeProtocol) this.protocol).sendQueryString(callingQuery, query, this.characterEncoding.getValue(), maxRows, streamResults, + cachedMetadata, resultSetFactory) + : ((NativeProtocol) this.protocol).sendQueryPacket(callingQuery, packet, maxRows, streamResults, cachedMetadata, resultSetFactory); + + } catch (CJException sqlE) { + if (getPropertySet().getBooleanProperty(PropertyKey.dumpQueriesOnException).getValue()) { + String extractedSql = NativePacketPayload.extractSqlFromPacket(query, packet, endOfQueryPacketPosition, + getPropertySet().getIntegerProperty(PropertyKey.maxQuerySizeToLog).getValue()); + StringBuilder messageBuf = new StringBuilder(extractedSql.length() + 32); + messageBuf.append("\n\nQuery being executed when exception was thrown:\n"); + messageBuf.append(extractedSql); + messageBuf.append("\n\n"); + sqlE.appendMessage(messageBuf.toString()); + } + + if ((this.autoReconnect.getValue())) { + if (sqlE instanceof CJCommunicationsException) { + // IO may be dirty or damaged beyond repair, force close it. + this.protocol.getSocketConnection().forceClose(); + } + this.needsPing = true; + } else if (sqlE instanceof CJCommunicationsException) { + invokeCleanupListeners(sqlE); + } + throw sqlE; + + } catch (Throwable ex) { + if (this.autoReconnect.getValue()) { + if (ex instanceof IOException) { + // IO may be dirty or damaged beyond repair, force close it. + this.protocol.getSocketConnection().forceClose(); + } else if (ex instanceof IOException) { + invokeCleanupListeners(ex); + } + this.needsPing = true; + } + throw ExceptionFactory.createException(ex.getMessage(), ex, this.exceptionInterceptor); + + } finally { + if (this.maintainTimeStats.getValue()) { + this.lastQueryFinishedTime = System.currentTimeMillis(); + } + + if (this.gatherPerfMetrics.getValue()) { + ((NativeProtocol) this.protocol).getMetricsHolder().registerQueryExecutionTime(System.currentTimeMillis() - queryStartTime); + } + } + + } + + public long getIdleFor() { + return this.lastQueryFinishedTime == 0 ? 0 : System.currentTimeMillis() - this.lastQueryFinishedTime; + } + + public boolean isNeedsPing() { + return this.needsPing; + } + + public void setNeedsPing(boolean needsPing) { + this.needsPing = needsPing; + } + + public void ping(boolean checkForClosedConnection, int timeoutMillis) { + if (checkForClosedConnection) { + checkClosed(); + } + + long pingMillisLifetime = getPropertySet().getIntegerProperty(PropertyKey.selfDestructOnPingSecondsLifetime).getValue(); + int pingMaxOperations = getPropertySet().getIntegerProperty(PropertyKey.selfDestructOnPingMaxOperations).getValue(); + + if ((pingMillisLifetime > 0 && (System.currentTimeMillis() - this.connectionCreationTimeMillis) > pingMillisLifetime) + || (pingMaxOperations > 0 && pingMaxOperations <= getCommandCount())) { + + invokeNormalCloseListeners(); + + throw ExceptionFactory.createException(Messages.getString("Connection.exceededConnectionLifetime"), + MysqlErrorNumbers.SQL_STATE_COMMUNICATION_LINK_FAILURE, 0, false, null, this.exceptionInterceptor); + } + sendCommand(this.commandBuilder.buildComPing(null), false, timeoutMillis); // it isn't safe to use a shared packet here + } + + public long getConnectionCreationTimeMillis() { + return this.connectionCreationTimeMillis; + } + + public void setConnectionCreationTimeMillis(long connectionCreationTimeMillis) { + this.connectionCreationTimeMillis = connectionCreationTimeMillis; + } + + public boolean isClosed() { + return this.isClosed; + } + + public void checkClosed() { + if (this.isClosed) { + if (this.forceClosedReason != null && this.forceClosedReason.getClass().equals(OperationCancelledException.class)) { + throw (OperationCancelledException) this.forceClosedReason; + } + throw ExceptionFactory.createException(ConnectionIsClosedException.class, Messages.getString("Connection.2"), this.forceClosedReason, + getExceptionInterceptor()); + } + } + + public Throwable getForceClosedReason() { + return this.forceClosedReason; + } + + public void setForceClosedReason(Throwable forceClosedReason) { + this.forceClosedReason = forceClosedReason; + } + + @Override + public void addListener(SessionEventListener l) { + this.listeners.addIfAbsent(new WeakReference<>(l)); + } + + @Override + public void removeListener(SessionEventListener listener) { + for (WeakReference wr : this.listeners) { + SessionEventListener l = wr.get(); + if (l == listener) { + this.listeners.remove(wr); + break; + } + } + } + + protected void invokeNormalCloseListeners() { + for (WeakReference wr : this.listeners) { + SessionEventListener l = wr.get(); + if (l != null) { + l.handleNormalClose(); + } else { + this.listeners.remove(wr); + } + } + } + + protected void invokeReconnectListeners() { + for (WeakReference wr : this.listeners) { + SessionEventListener l = wr.get(); + if (l != null) { + l.handleReconnect(); + } else { + this.listeners.remove(wr); + } + } + } + + public void invokeCleanupListeners(Throwable whyCleanedUp) { + for (WeakReference wr : this.listeners) { + SessionEventListener l = wr.get(); + if (l != null) { + l.handleCleanup(whyCleanedUp); + } else { + this.listeners.remove(wr); + } + } + } + + @Override + public String getIdentifierQuoteString() { + return this.protocol != null && this.protocol.getServerSession().useAnsiQuotedIdentifiers() ? "\"" : "`"; + } + + public synchronized Timer getCancelTimer() { + if (this.cancelTimer == null) { + this.cancelTimer = new Timer("MySQL Statement Cancellation Timer", Boolean.TRUE); + } + return this.cancelTimer; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/NoSubInterceptorWrapper.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/NoSubInterceptorWrapper.java new file mode 100644 index 0000000..b2f3d11 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/NoSubInterceptorWrapper.java @@ -0,0 +1,98 @@ +/* + * Copyright (c) 2009, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.util.Properties; +import java.util.function.Supplier; + +import com.mysql.cj.interceptors.QueryInterceptor; +import com.mysql.cj.log.Log; +import com.mysql.cj.protocol.Message; +import com.mysql.cj.protocol.Resultset; +import com.mysql.cj.protocol.ServerSession; + +/** + * Wraps query interceptors during driver startup so that they don't produce different result sets than we expect. + */ +public class NoSubInterceptorWrapper implements QueryInterceptor { + + private final QueryInterceptor underlyingInterceptor; + + public NoSubInterceptorWrapper(QueryInterceptor underlyingInterceptor) { + if (underlyingInterceptor == null) { + throw new RuntimeException(Messages.getString("NoSubInterceptorWrapper.0")); + } + + this.underlyingInterceptor = underlyingInterceptor; + } + + public void destroy() { + this.underlyingInterceptor.destroy(); + } + + public boolean executeTopLevelOnly() { + return this.underlyingInterceptor.executeTopLevelOnly(); + } + + public QueryInterceptor init(MysqlConnection conn, Properties props, Log log) { + this.underlyingInterceptor.init(conn, props, log); + return this; + } + + public T postProcess(Supplier sql, Query interceptedQuery, T originalResultSet, ServerSession serverSession) { + this.underlyingInterceptor.postProcess(sql, interceptedQuery, originalResultSet, serverSession); + + return null; // don't allow result set substitution + } + + public T preProcess(Supplier sql, Query interceptedQuery) { + this.underlyingInterceptor.preProcess(sql, interceptedQuery); + + return null; // don't allow result set substitution + } + + @Override + public M preProcess(M queryPacket) { + this.underlyingInterceptor.preProcess(queryPacket); + + return null; // don't allow PacketPayload substitution + } + + @Override + public M postProcess(M queryPacket, M originalResponsePacket) { + this.underlyingInterceptor.postProcess(queryPacket, originalResponsePacket); + + return null; // don't allow PacketPayload substitution + } + + public QueryInterceptor getUnderlyingInterceptor() { + return this.underlyingInterceptor; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/ServerPreparedQuery.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/ServerPreparedQuery.java new file mode 100644 index 0000000..a6d0e41 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/ServerPreparedQuery.java @@ -0,0 +1,817 @@ +/* + * Copyright (c) 2017, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.io.IOException; +import java.io.InputStream; +import java.io.Reader; + +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.conf.RuntimeProperty; +import com.mysql.cj.exceptions.CJException; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.MysqlErrorNumbers; +import com.mysql.cj.exceptions.WrongArgumentException; +import com.mysql.cj.log.ProfilerEvent; +import com.mysql.cj.protocol.ColumnDefinition; +import com.mysql.cj.protocol.Message; +import com.mysql.cj.protocol.ProtocolEntityFactory; +import com.mysql.cj.protocol.Resultset; +import com.mysql.cj.protocol.Resultset.Type; +import com.mysql.cj.protocol.a.ColumnDefinitionFactory; +import com.mysql.cj.protocol.a.NativeConstants; +import com.mysql.cj.protocol.a.NativeConstants.IntegerDataType; +import com.mysql.cj.protocol.a.NativeConstants.StringLengthDataType; +import com.mysql.cj.protocol.a.NativeConstants.StringSelfDataType; +import com.mysql.cj.protocol.a.NativeMessageBuilder; +import com.mysql.cj.protocol.a.NativePacketPayload; +import com.mysql.cj.protocol.a.ValueEncoder; +import com.mysql.cj.result.Field; +import com.mysql.cj.util.StringUtils; + +//TODO should not be protocol-specific + +public class ServerPreparedQuery extends AbstractPreparedQuery { + + public static final int BLOB_STREAM_READ_BUF_SIZE = 8192; + public static final byte OPEN_CURSOR_FLAG = 0x01; + public static final byte PARAMETER_COUNT_AVAILABLE = 0x08; + + /** The ID that the server uses to identify this PreparedStatement */ + private long serverStatementId; + + /** Field-level metadata for parameters */ + private Field[] parameterFields; + + /** Field-level metadata for result sets. From statement prepare. */ + private ColumnDefinition resultFields; + + /** The "profileSQL" connection property value */ + protected boolean profileSQL = false; + + /** The "gatherPerfMetrics" connection property value */ + protected boolean gatherPerfMetrics; + + /** The "logSlowQueries" connection property value */ + protected boolean logSlowQueries = false; + + private boolean useAutoSlowLog; + + protected RuntimeProperty slowQueryThresholdMillis; + + protected RuntimeProperty explainSlowQueries; + protected boolean useCursorFetch = false; + + protected boolean queryWasSlow = false; + + protected NativeMessageBuilder commandBuilder = null; + + public static ServerPreparedQuery getInstance(NativeSession sess) { + if (sess.getPropertySet().getBooleanProperty(PropertyKey.autoGenerateTestcaseScript).getValue()) { + return new ServerPreparedQueryTestcaseGenerator(sess); + } + return new ServerPreparedQuery(sess); + } + + protected ServerPreparedQuery(NativeSession sess) { + super(sess); + this.profileSQL = sess.getPropertySet().getBooleanProperty(PropertyKey.profileSQL).getValue(); + this.gatherPerfMetrics = sess.getPropertySet().getBooleanProperty(PropertyKey.gatherPerfMetrics).getValue(); + this.logSlowQueries = sess.getPropertySet().getBooleanProperty(PropertyKey.logSlowQueries).getValue(); + this.useAutoSlowLog = sess.getPropertySet().getBooleanProperty(PropertyKey.autoSlowLog).getValue(); + this.slowQueryThresholdMillis = sess.getPropertySet().getIntegerProperty(PropertyKey.slowQueryThresholdMillis); + this.explainSlowQueries = sess.getPropertySet().getBooleanProperty(PropertyKey.explainSlowQueries); + this.useCursorFetch = sess.getPropertySet().getBooleanProperty(PropertyKey.useCursorFetch).getValue(); + this.commandBuilder = new NativeMessageBuilder(this.session.getServerSession().supportsQueryAttributes()); + } + + /** + * + * @param sql + * query string + * @throws IOException + * if an i/o error occurs + */ + public void serverPrepare(String sql) throws IOException { + this.session.checkClosed(); + + synchronized (this.session) { + long begin = this.profileSQL ? System.currentTimeMillis() : 0; + + boolean loadDataQuery = StringUtils.startsWithIgnoreCaseAndWs(sql, "LOAD DATA"); + + String characterEncoding = null; + String connectionEncoding = this.session.getPropertySet().getStringProperty(PropertyKey.characterEncoding).getValue(); + + if (!loadDataQuery && (connectionEncoding != null)) { + characterEncoding = connectionEncoding; + } + + NativePacketPayload prepareResultPacket = this.session + .sendCommand(this.commandBuilder.buildComStmtPrepare(this.session.getSharedSendPacket(), sql, characterEncoding), false, 0); + + // 4.1.1 and newer use the first byte as an 'ok' or 'error' flag, so move the buffer pointer past it to start reading the statement id. + prepareResultPacket.setPosition(1); + + this.serverStatementId = prepareResultPacket.readInteger(IntegerDataType.INT4); + int fieldCount = (int) prepareResultPacket.readInteger(IntegerDataType.INT2); + setParameterCount((int) prepareResultPacket.readInteger(IntegerDataType.INT2)); + + this.queryBindings = new ServerPreparedQueryBindings(this.parameterCount, this.session); + this.queryBindings.setLoadDataQuery(loadDataQuery); + + if (this.gatherPerfMetrics) { + this.session.getProtocol().getMetricsHolder().incrementNumberOfPrepares(); + } + + if (this.profileSQL) { + this.session.getProfilerEventHandler().processEvent(ProfilerEvent.TYPE_PREPARE, this.session, this, null, + this.session.getCurrentTimeNanosOrMillis() - begin, new Throwable(), truncateQueryToLog(sql)); + } + + boolean checkEOF = !this.session.getServerSession().isEOFDeprecated(); + + if (this.parameterCount > 0) { + if (checkEOF) { // Skip the following EOF packet. + this.session.getProtocol().skipPacket(); + } + + this.parameterFields = this.session.getProtocol().read(ColumnDefinition.class, new ColumnDefinitionFactory(this.parameterCount, null)) + .getFields(); + } + + // Read in the result set column information + if (fieldCount > 0) { + this.resultFields = this.session.getProtocol().read(ColumnDefinition.class, new ColumnDefinitionFactory(fieldCount, null)); + } + } + } + + @Override + public void statementBegins() { + super.statementBegins(); + this.queryWasSlow = false; + } + + /** + * @param + * extends {@link Resultset} + * @param maxRowsToRetrieve + * rows limit + * @param createStreamingResultSet + * should c/J create a streaming result? + * @param metadata + * use this metadata instead of the one provided on wire + * @param resultSetFactory + * {@link ProtocolEntityFactory} + * @return T instance + */ + public T serverExecute(int maxRowsToRetrieve, boolean createStreamingResultSet, ColumnDefinition metadata, + ProtocolEntityFactory resultSetFactory) { + if (this.session.shouldIntercept()) { + T interceptedResults = this.session.invokeQueryInterceptorsPre(() -> { + return getOriginalSql(); + }, this, true); + + if (interceptedResults != null) { + return interceptedResults; + } + } + String queryAsString = this.profileSQL || this.logSlowQueries || this.gatherPerfMetrics ? asSql(true) : ""; + + NativePacketPayload packet = prepareExecutePacket(); + NativePacketPayload resPacket = sendExecutePacket(packet, queryAsString); + T rs = readExecuteResult(resPacket, maxRowsToRetrieve, createStreamingResultSet, metadata, resultSetFactory, queryAsString); + + return rs; + } + + public NativePacketPayload prepareExecutePacket() { + ServerPreparedQueryBindValue[] parameterBindings = this.queryBindings.getBindValues(); + + if (this.queryBindings.isLongParameterSwitchDetected()) { + // Check when values were bound + boolean firstFound = false; + long boundTimeToCheck = 0; + + for (int i = 0; i < this.parameterCount - 1; i++) { + if (parameterBindings[i].isStream()) { + if (firstFound && boundTimeToCheck != parameterBindings[i].boundBeforeExecutionNum) { + throw ExceptionFactory.createException( + Messages.getString("ServerPreparedStatement.11") + Messages.getString("ServerPreparedStatement.12"), + MysqlErrorNumbers.SQL_STATE_DRIVER_NOT_CAPABLE, 0, true, null, this.session.getExceptionInterceptor()); + } + firstFound = true; + boundTimeToCheck = parameterBindings[i].boundBeforeExecutionNum; + } + } + + // Okay, we've got all "newly"-bound streams, so reset server-side state to clear out previous bindings + serverResetStatement(); + } + + this.queryBindings.checkAllParametersSet(); + + // + // Send all long data + // + for (int i = 0; i < this.parameterCount; i++) { + if (parameterBindings[i].isStream()) { + serverLongData(i, parameterBindings[i]); + } + } + + // + // store the parameter values + // + NativePacketPayload packet = this.session.getSharedSendPacket(); + + packet.writeInteger(IntegerDataType.INT1, NativeConstants.COM_STMT_EXECUTE); + packet.writeInteger(IntegerDataType.INT4, this.serverStatementId); + + boolean supportsQueryAttributes = this.session.getServerSession().supportsQueryAttributes(); + boolean sendQueryAttributes = false; + if (supportsQueryAttributes) { + // Servers between 8.0.23 8.0.25 are affected by Bug#103102, Bug#103268 and Bug#103377. Query attributes cannot be sent to these servers. + sendQueryAttributes = this.session.getServerSession().getServerVersion().meetsMinimum(new ServerVersion(8, 0, 26)); + } else if (this.queryAttributesBindings.getCount() > 0) { + this.session.getLog().logWarn(Messages.getString("QueryAttributes.SetButNotSupported")); + } + + byte flags = 0; + if (this.resultFields != null && this.resultFields.getFields() != null && this.useCursorFetch && this.resultSetType == Type.FORWARD_ONLY + && this.fetchSize > 0) { + // we only create cursor-backed result sets if + // a) The query is a SELECT + // b) The server supports it + // c) We know it is forward-only (note this doesn't preclude updatable result sets) + // d) The user has set a fetch size + flags |= OPEN_CURSOR_FLAG; + } + if (sendQueryAttributes) { + flags |= PARAMETER_COUNT_AVAILABLE; + } + packet.writeInteger(IntegerDataType.INT1, flags); + + packet.writeInteger(IntegerDataType.INT4, 1); // placeholder for parameter iterations + + int parametersAndAttributesCount = this.parameterCount; + if (supportsQueryAttributes) { + if (sendQueryAttributes) { + parametersAndAttributesCount += this.queryAttributesBindings.getCount(); + } + if (sendQueryAttributes || parametersAndAttributesCount > 0) { + // Servers between 8.0.23 and 8.0.25 don't expect a 'parameter_count' value if the statement was prepared without parameters. + packet.writeInteger(IntegerDataType.INT_LENENC, parametersAndAttributesCount); + } + } + + if (parametersAndAttributesCount > 0) { + /* Reserve place for null-marker bytes */ + int nullCount = (parametersAndAttributesCount + 7) / 8; + + int nullBitsPosition = packet.getPosition(); + + for (int i = 0; i < nullCount; i++) { + packet.writeInteger(IntegerDataType.INT1, 0); + } + + byte[] nullBitsBuffer = new byte[nullCount]; + + // In case if buffers (type) changed or there are query attributes to send. + if (this.queryBindings.getSendTypesToServer().get() || sendQueryAttributes && this.queryAttributesBindings.getCount() > 0) { + packet.writeInteger(IntegerDataType.INT1, 1); + + // Store types of parameters in the first package that is sent to the server. + for (int i = 0; i < this.parameterCount; i++) { + packet.writeInteger(IntegerDataType.INT2, parameterBindings[i].bufferType); + if (supportsQueryAttributes) { + packet.writeBytes(StringSelfDataType.STRING_LENENC, "".getBytes()); // Parameters have no names. + } + } + + if (sendQueryAttributes) { + this.queryAttributesBindings.runThroughAll(a -> { + packet.writeInteger(IntegerDataType.INT2, a.getType()); + packet.writeBytes(StringSelfDataType.STRING_LENENC, a.getName().getBytes()); + }); + } + } else { + packet.writeInteger(IntegerDataType.INT1, 0); + } + + // Store the parameter values. + for (int i = 0; i < this.parameterCount; i++) { + if (!parameterBindings[i].isStream()) { + if (!parameterBindings[i].isNull()) { + parameterBindings[i].storeBinding(packet, this.queryBindings.isLoadDataQuery(), this.charEncoding, + this.session.getExceptionInterceptor()); + } else { + nullBitsBuffer[i >>> 3] |= (1 << (i & 7)); + } + } + } + + if (sendQueryAttributes) { + for (int i = 0; i < this.queryAttributesBindings.getCount(); i++) { + if (this.queryAttributesBindings.getAttributeValue(i).isNull()) { + int b = i + this.parameterCount; + nullBitsBuffer[b >>> 3] |= 1 << (b & 7); + } + } + ValueEncoder valueEncoder = new ValueEncoder(packet, this.charEncoding, this.session.getServerSession().getDefaultTimeZone()); + this.queryAttributesBindings.runThroughAll(a -> valueEncoder.encodeValue(a.getValue(), a.getType())); + } + + // Go back and write the NULL flags to the beginning of the packet + int endPosition = packet.getPosition(); + packet.setPosition(nullBitsPosition); + packet.writeBytes(StringLengthDataType.STRING_FIXED, nullBitsBuffer); + packet.setPosition(endPosition); + } + + return packet; + } + + public NativePacketPayload sendExecutePacket(NativePacketPayload packet, String queryAsString) { // TODO queryAsString should be shared instead of passed + + final long begin = this.session.getCurrentTimeNanosOrMillis(); + + resetCancelledState(); + + CancelQueryTask timeoutTask = null; + + try { + // Get this before executing to avoid a shared packet pollution in the case some other query is issued internally, such as when using I_S. + + timeoutTask = startQueryTimer(this, this.timeoutInMillis); + + statementBegins(); + + NativePacketPayload resultPacket = this.session.sendCommand(packet, false, 0); + + final long queryEndTime = this.session.getCurrentTimeNanosOrMillis(); + + if (timeoutTask != null) { + stopQueryTimer(timeoutTask, true, true); + timeoutTask = null; + } + + final long executeTime = queryEndTime - begin; + setExecuteTime(executeTime); + + if (this.logSlowQueries) { + this.queryWasSlow = this.useAutoSlowLog ? // + this.session.getProtocol().getMetricsHolder().checkAbonormallyLongQuery(executeTime) + : executeTime > this.slowQueryThresholdMillis.getValue(); + + if (this.queryWasSlow) { + this.session.getProfilerEventHandler().processEvent(ProfilerEvent.TYPE_SLOW_QUERY, this.session, this, null, executeTime, new Throwable(), + Messages.getString("ServerPreparedStatement.15", new String[] { String.valueOf(this.session.getSlowQueryThreshold()), + String.valueOf(executeTime), this.originalSql, queryAsString })); + } + } + + if (this.gatherPerfMetrics) { + this.session.getProtocol().getMetricsHolder().registerQueryExecutionTime(executeTime); + this.session.getProtocol().getMetricsHolder().incrementNumberOfPreparedExecutes(); + } + + if (this.profileSQL) { + this.session.getProfilerEventHandler().processEvent(ProfilerEvent.TYPE_EXECUTE, this.session, this, null, executeTime, new Throwable(), + truncateQueryToLog(queryAsString)); + } + + return resultPacket; + + } catch (CJException sqlEx) { + if (this.session.shouldIntercept()) { + this.session.invokeQueryInterceptorsPost(() -> { + return getOriginalSql(); + }, this, null, true); + } + + throw sqlEx; + } finally { + this.statementExecuting.set(false); + stopQueryTimer(timeoutTask, false, false); + } + } + + public T readExecuteResult(NativePacketPayload resultPacket, int maxRowsToRetrieve, boolean createStreamingResultSet, + ColumnDefinition metadata, ProtocolEntityFactory resultSetFactory, String queryAsString) { // TODO queryAsString should be shared instead of passed + try { + long fetchStartTime = this.profileSQL ? this.session.getCurrentTimeNanosOrMillis() : 0; + + T rs = this.session.getProtocol().readAllResults(maxRowsToRetrieve, createStreamingResultSet, resultPacket, true, + metadata != null ? metadata : this.resultFields, resultSetFactory); + + if (this.session.shouldIntercept()) { + T interceptedResults = this.session.invokeQueryInterceptorsPost(() -> { + return getOriginalSql(); + }, this, rs, true); + + if (interceptedResults != null) { + rs = interceptedResults; + } + } + + if (this.profileSQL) { + this.session.getProfilerEventHandler().processEvent(ProfilerEvent.TYPE_FETCH, this.session, this, rs, + this.session.getCurrentTimeNanosOrMillis() - fetchStartTime, new Throwable(), null); + } + + if (this.queryWasSlow && this.explainSlowQueries.getValue()) { + this.session.getProtocol().explainSlowQuery(queryAsString, queryAsString); + } + + this.queryBindings.getSendTypesToServer().set(false); + + if (this.session.hadWarnings()) { + this.session.getProtocol().scanForAndThrowDataTruncation(); + } + + return rs; + } catch (IOException ioEx) { + throw ExceptionFactory.createCommunicationsException(this.session.getPropertySet(), this.session.getServerSession(), + this.session.getProtocol().getPacketSentTimeHolder(), this.session.getProtocol().getPacketReceivedTimeHolder(), ioEx, + this.session.getExceptionInterceptor()); + } catch (CJException sqlEx) { + if (this.session.shouldIntercept()) { + this.session.invokeQueryInterceptorsPost(() -> { + return getOriginalSql(); + }, this, null, true); + } + + throw sqlEx; + } + + } + + /** + * Sends stream-type data parameters to the server. + * + * 

+     *  Long data handling:
+     * 
+     *  - Server gets the long data in pieces with command type 'COM_LONG_DATA'.
+     *  - The packet received will have the format:
+     *    [COM_LONG_DATA:     1][STMT_ID:4][parameter_number:2][type:2][data]
+     *  - Checks if the type is specified by client, and if yes reads the type,
+     *    and  stores the data in that format.
+     *  - It is up to the client to check for read data ended. The server does not
+     *    care; and also server does not notify to the client that it got the
+     *    data  or not; if there is any error; then during execute; the error
+     *    will  be returned
+     *
+ * + * @param parameterIndex + * parameter index + * @param longData + * {@link ServerPreparedQueryBindValue containing long data} + * + */ + private void serverLongData(int parameterIndex, ServerPreparedQueryBindValue longData) { + synchronized (this) { + NativePacketPayload packet = this.session.getSharedSendPacket(); + + Object value = longData.value; + + if (value instanceof byte[]) { + this.session.sendCommand(this.commandBuilder.buildComStmtSendLongData(packet, this.serverStatementId, parameterIndex, (byte[]) value), true, 0); + } else if (value instanceof InputStream) { + storeStream(parameterIndex, packet, (InputStream) value); + } else if (value instanceof java.sql.Blob) { + try { + storeStream(parameterIndex, packet, ((java.sql.Blob) value).getBinaryStream()); + } catch (Throwable t) { + throw ExceptionFactory.createException(t.getMessage(), this.session.getExceptionInterceptor()); + } + } else if (value instanceof Reader) { + storeReader(parameterIndex, packet, (Reader) value); + } else { + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("ServerPreparedStatement.18") + value.getClass().getName() + "'", this.session.getExceptionInterceptor()); + } + } + } + + @Override + public void closeQuery() { + this.queryBindings = null; + this.parameterFields = null; + this.resultFields = null; + super.closeQuery(); + } + + public long getServerStatementId() { + return this.serverStatementId; + } + + public void setServerStatementId(long serverStatementId) { + this.serverStatementId = serverStatementId; + } + + public Field[] getParameterFields() { + return this.parameterFields; + } + + public void setParameterFields(Field[] parameterFields) { + this.parameterFields = parameterFields; + } + + public ColumnDefinition getResultFields() { + return this.resultFields; + } + + public void setResultFields(ColumnDefinition resultFields) { + this.resultFields = resultFields; + } + + public void storeStream(int parameterIndex, NativePacketPayload packet, InputStream inStream) { + this.session.checkClosed(); + synchronized (this.session) { + byte[] buf = new byte[BLOB_STREAM_READ_BUF_SIZE]; + + int numRead = 0; + + try { + int bytesInPacket = 0; + int totalBytesRead = 0; + int bytesReadAtLastSend = 0; + int packetIsFullAt = this.session.getPropertySet().getMemorySizeProperty(PropertyKey.blobSendChunkSize).getValue(); + + packet.setPosition(0); + packet.writeInteger(IntegerDataType.INT1, NativeConstants.COM_STMT_SEND_LONG_DATA); + packet.writeInteger(IntegerDataType.INT4, this.serverStatementId); + packet.writeInteger(IntegerDataType.INT2, parameterIndex); + + boolean readAny = false; + + while ((numRead = inStream.read(buf)) != -1) { + + readAny = true; + + packet.writeBytes(StringLengthDataType.STRING_FIXED, buf, 0, numRead); + bytesInPacket += numRead; + totalBytesRead += numRead; + + if (bytesInPacket >= packetIsFullAt) { + bytesReadAtLastSend = totalBytesRead; + + this.session.sendCommand(packet, true, 0); + + bytesInPacket = 0; + packet.setPosition(0); + packet.writeInteger(IntegerDataType.INT1, NativeConstants.COM_STMT_SEND_LONG_DATA); + packet.writeInteger(IntegerDataType.INT4, this.serverStatementId); + packet.writeInteger(IntegerDataType.INT2, parameterIndex); + } + } + + if (totalBytesRead != bytesReadAtLastSend) { + this.session.sendCommand(packet, true, 0); + } + + if (!readAny) { + this.session.sendCommand(packet, true, 0); + } + } catch (IOException ioEx) { + throw ExceptionFactory.createException(Messages.getString("ServerPreparedStatement.25") + ioEx.toString(), ioEx, + this.session.getExceptionInterceptor()); + } finally { + if (this.autoClosePStmtStreams.getValue()) { + if (inStream != null) { + try { + inStream.close(); + } catch (IOException ioEx) { + // ignore + } + } + } + } + } + } + + // TODO: Investigate using NIO to do this faster + public void storeReader(int parameterIndex, NativePacketPayload packet, Reader inStream) { + this.session.checkClosed(); + synchronized (this.session) { + String forcedEncoding = this.session.getPropertySet().getStringProperty(PropertyKey.clobCharacterEncoding).getStringValue(); + + String clobEncoding = (forcedEncoding == null ? this.session.getPropertySet().getStringProperty(PropertyKey.characterEncoding).getValue() + : forcedEncoding); + + int maxBytesChar = 2; + + if (clobEncoding != null) { + if (!clobEncoding.equals("UTF-16")) { + maxBytesChar = this.session.getServerSession().getCharsetSettings().getMaxBytesPerChar(clobEncoding); + + if (maxBytesChar == 1) { + maxBytesChar = 2; // for safety + } + } else { + maxBytesChar = 4; + } + } + + char[] buf = new char[ServerPreparedQuery.BLOB_STREAM_READ_BUF_SIZE / maxBytesChar]; + + int numRead = 0; + + int bytesInPacket = 0; + int totalBytesRead = 0; + int bytesReadAtLastSend = 0; + int packetIsFullAt = this.session.getPropertySet().getMemorySizeProperty(PropertyKey.blobSendChunkSize).getValue(); + + try { + packet.setPosition(0); + packet.writeInteger(IntegerDataType.INT1, NativeConstants.COM_STMT_SEND_LONG_DATA); + packet.writeInteger(IntegerDataType.INT4, this.serverStatementId); + packet.writeInteger(IntegerDataType.INT2, parameterIndex); + + boolean readAny = false; + + while ((numRead = inStream.read(buf)) != -1) { + readAny = true; + + byte[] valueAsBytes = StringUtils.getBytes(buf, 0, numRead, clobEncoding); + + packet.writeBytes(StringSelfDataType.STRING_EOF, valueAsBytes); + + bytesInPacket += valueAsBytes.length; + totalBytesRead += valueAsBytes.length; + + if (bytesInPacket >= packetIsFullAt) { + bytesReadAtLastSend = totalBytesRead; + + this.session.sendCommand(packet, true, 0); + + bytesInPacket = 0; + packet.setPosition(0); + packet.writeInteger(IntegerDataType.INT1, NativeConstants.COM_STMT_SEND_LONG_DATA); + packet.writeInteger(IntegerDataType.INT4, this.serverStatementId); + packet.writeInteger(IntegerDataType.INT2, parameterIndex); + } + } + + if (totalBytesRead != bytesReadAtLastSend) { + this.session.sendCommand(packet, true, 0); + } + + if (!readAny) { + this.session.sendCommand(packet, true, 0); + } + } catch (IOException ioEx) { + throw ExceptionFactory.createException(Messages.getString("ServerPreparedStatement.24") + ioEx.toString(), ioEx, + this.session.getExceptionInterceptor()); + } finally { + if (this.autoClosePStmtStreams.getValue()) { + if (inStream != null) { + try { + inStream.close(); + } catch (IOException ioEx) { + // ignore + } + } + } + } + } + } + + /** + * @param clearServerParameters + * flag indicating whether we need an additional clean up + */ + public void clearParameters(boolean clearServerParameters) { + boolean hadLongData = false; + + if (this.queryBindings != null) { + hadLongData = this.queryBindings.clearBindValues(); + this.queryBindings.setLongParameterSwitchDetected(clearServerParameters && hadLongData ? false : true); + } + + if (clearServerParameters && hadLongData) { + serverResetStatement(); + } + } + + public void serverResetStatement() { + this.session.checkClosed(); + synchronized (this.session) { + try { + this.session.sendCommand(this.commandBuilder.buildComStmtReset(this.session.getSharedSendPacket(), this.serverStatementId), false, 0); + } finally { + this.session.clearInputStream(); + } + } + } + + /** + * Computes the maximum parameter set size and the size of the entire batch given + * the number of arguments in the batch. + */ + @Override + protected long[] computeMaxParameterSetSizeAndBatchSize(int numBatchedArgs) { + boolean supportsQueryAttributes = this.session.getServerSession().supportsQueryAttributes(); + + long maxSizeOfParameterSet = 0; + long sizeOfEntireBatch = 1 /* com_stmt_execute */ + 4 /* statement_id */ + 1 /* flags */ + 4 /* iteration_count */ + 1 /* new_params_bind_flag */; + if (supportsQueryAttributes) { + sizeOfEntireBatch += 9 /* parameter_count */; + sizeOfEntireBatch += (this.queryAttributesBindings.getCount() + 7) / 8 /* null_bitmap */; + for (int i = 0; i < this.queryAttributesBindings.getCount(); i++) { + QueryAttributesBindValue queryAttribute = this.queryAttributesBindings.getAttributeValue(i); + sizeOfEntireBatch += 2 /* parameter_type */ + queryAttribute.getName().length() /* parameter_name */ + queryAttribute.getBoundLength(); + } + } + + for (int i = 0; i < numBatchedArgs; i++) { + ServerPreparedQueryBindValue[] paramArg = ((ServerPreparedQueryBindings) this.batchedArgs.get(i)).getBindValues(); + + long sizeOfParameterSet = (this.parameterCount + 7) / 8 /* null_bitmap */ + + this.parameterCount * 2 /* parameter_type */; + if (supportsQueryAttributes) { + sizeOfParameterSet += this.parameterCount /* parameter_name (all empty) */; + } + + ServerPreparedQueryBindValue[] parameterBindings = this.queryBindings.getBindValues(); + for (int j = 0; j < parameterBindings.length; j++) { + if (!paramArg[j].isNull()) { + long size = paramArg[j].getBoundLength(); + if (paramArg[j].isStream()) { + if (size != -1) { + sizeOfParameterSet += size; + } + } else { + sizeOfParameterSet += size; + } + } + } + + sizeOfEntireBatch += sizeOfParameterSet; + + if (sizeOfParameterSet > maxSizeOfParameterSet) { + maxSizeOfParameterSet = sizeOfParameterSet; + } + } + + return new long[] { maxSizeOfParameterSet, sizeOfEntireBatch }; + } + + private String truncateQueryToLog(String sql) { + String queryStr = null; + + int maxQuerySizeToLog = this.session.getPropertySet().getIntegerProperty(PropertyKey.maxQuerySizeToLog).getValue(); + if (sql.length() > maxQuerySizeToLog) { + StringBuilder queryBuf = new StringBuilder(maxQuerySizeToLog + 12); + queryBuf.append(sql.substring(0, maxQuerySizeToLog)); + queryBuf.append(Messages.getString("MysqlIO.25")); + + queryStr = queryBuf.toString(); + } else { + queryStr = sql; + } + + return queryStr; + } + + @Override + public M fillSendPacket() { + return null; // we don't use this type of packet + } + + @Override + public M fillSendPacket(QueryBindings bindings) { + return null; // we don't use this type of packet + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/ServerPreparedQueryBindValue.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/ServerPreparedQueryBindValue.java new file mode 100644 index 0000000..313da18 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/ServerPreparedQueryBindValue.java @@ -0,0 +1,492 @@ +/* + * Copyright (c) 2017, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.time.Duration; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.time.format.DateTimeFormatter; +import java.time.format.DateTimeFormatterBuilder; +import java.time.temporal.ChronoField; +import java.util.Calendar; +import java.util.Locale; +import java.util.TimeZone; + +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.conf.RuntimeProperty; +import com.mysql.cj.exceptions.CJException; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.ExceptionInterceptor; +import com.mysql.cj.protocol.a.NativeConstants.IntegerDataType; +import com.mysql.cj.protocol.a.NativeConstants.StringSelfDataType; +import com.mysql.cj.protocol.a.NativePacketPayload; +import com.mysql.cj.util.StringUtils; +import com.mysql.cj.util.TimeUtil; + +//TODO should not be protocol-specific + +public class ServerPreparedQueryBindValue extends ClientPreparedQueryBindValue implements BindValue { + + public long boundBeforeExecutionNum = 0; + + public int bufferType; + + /* Calendar to be used for DATE and DATETIME values storing */ + public Calendar calendar; + + PropertySet pset; + private TimeZone defaultTimeZone; + private TimeZone connectionTimeZone; + private RuntimeProperty cacheDefaultTimeZone = null; + + protected String charEncoding = null; + + public ServerPreparedQueryBindValue(TimeZone defaultTimeZone, TimeZone connectionTimeZone, PropertySet pset) { + this.pset = pset; + this.defaultTimeZone = defaultTimeZone; + this.connectionTimeZone = connectionTimeZone; + this.cacheDefaultTimeZone = pset.getBooleanProperty(PropertyKey.cacheDefaultTimeZone); + } + + @Override + public ServerPreparedQueryBindValue clone() { + return new ServerPreparedQueryBindValue(this); + } + + private ServerPreparedQueryBindValue(ServerPreparedQueryBindValue copyMe) { + super(copyMe); + + this.pset = copyMe.pset; + this.defaultTimeZone = copyMe.defaultTimeZone; + this.connectionTimeZone = copyMe.connectionTimeZone; + this.cacheDefaultTimeZone = copyMe.cacheDefaultTimeZone; + this.bufferType = copyMe.bufferType; + this.calendar = copyMe.calendar; + this.charEncoding = copyMe.charEncoding; + } + + @Override + public void reset() { + super.reset(); + this.calendar = null; + this.charEncoding = null; + } + + /** + * Reset a bind value to be used for a new value of the given type. + * + * @param bufType + * MysqlType.FIELD_TYPE_* + * @param numberOfExecutions + * current number of PreparedQuery executions + * @return true if we need to send/resend types to the server + */ + public boolean resetToType(int bufType, long numberOfExecutions) { + boolean sendTypesToServer = false; + + // clear any possible old value + reset(); + + if (bufType == MysqlType.FIELD_TYPE_NULL && this.bufferType != 0) { + // preserve the previous type to (possibly) avoid sending types at execution time + } else if (this.bufferType != bufType) { + sendTypesToServer = true; + this.bufferType = bufType; + } + + // setup bind value for use + this.isSet = true; + this.boundBeforeExecutionNum = numberOfExecutions; + return sendTypesToServer; + } + + @Override + public String toString() { + return toString(false); + } + + public String toString(boolean quoteIfNeeded) { + if (this.isStream) { + return "' STREAM DATA '"; + } + + if (this.isNull) { + return "NULL"; + } + + DateTimeFormatter timeFmtWithOptMicros = new DateTimeFormatterBuilder().appendPattern("HH:mm:ss").appendFraction(ChronoField.NANO_OF_SECOND, 0, 6, true) + .toFormatter(); + DateTimeFormatter datetimeFmtWithOptMicros = new DateTimeFormatterBuilder().appendPattern("yyyy-MM-dd HH:mm:ss") + .appendFraction(ChronoField.NANO_OF_SECOND, 0, 6, true).toFormatter(); + + switch (this.bufferType) { + case MysqlType.FIELD_TYPE_TINY: + case MysqlType.FIELD_TYPE_SHORT: + case MysqlType.FIELD_TYPE_LONG: + case MysqlType.FIELD_TYPE_LONGLONG: + return String.valueOf(((Long) this.value).longValue()); + case MysqlType.FIELD_TYPE_FLOAT: + return String.valueOf(((Float) this.value).floatValue()); + case MysqlType.FIELD_TYPE_DOUBLE: + return String.valueOf(((Double) this.value).doubleValue()); + case MysqlType.FIELD_TYPE_TIME: + String s; + if (this.value instanceof LocalDateTime) { + s = ((LocalDateTime) this.value).format(timeFmtWithOptMicros); + } else if (this.value instanceof LocalTime) { + s = ((LocalTime) this.value).format(timeFmtWithOptMicros); + } else if (this.value instanceof Duration) { + s = TimeUtil.getDurationString(((Duration) this.value)); + } else { + s = String.valueOf(this.value); + } + return "'" + s + "'"; + case MysqlType.FIELD_TYPE_DATE: + if (this.value instanceof LocalDate) { + s = ((LocalDate) this.value).format(TimeUtil.DATE_FORMATTER); + } else if (this.value instanceof LocalTime) { + s = ((LocalTime) this.value).atDate(LocalDate.of(1970, 1, 1)).format(TimeUtil.DATE_FORMATTER); + } else if (this.value instanceof LocalDateTime) { + s = ((LocalDateTime) this.value).format(TimeUtil.DATE_FORMATTER); + } else { + s = String.valueOf(this.value); + } + return "'" + s + "'"; + case MysqlType.FIELD_TYPE_DATETIME: + case MysqlType.FIELD_TYPE_TIMESTAMP: + if (this.value instanceof LocalDate) { + s = ((LocalDate) this.value).format(datetimeFmtWithOptMicros); + } else if (this.value instanceof LocalTime) { + s = ((LocalTime) this.value).atDate(LocalDate.of(1970, 1, 1)).format(timeFmtWithOptMicros); + } else if (this.value instanceof LocalDateTime) { + s = ((LocalDateTime) this.value).format(datetimeFmtWithOptMicros); + } else { + s = String.valueOf(this.value); + } + return "'" + s + "'"; + case MysqlType.FIELD_TYPE_VAR_STRING: + case MysqlType.FIELD_TYPE_STRING: + case MysqlType.FIELD_TYPE_VARCHAR: + if (quoteIfNeeded) { + return "'" + String.valueOf(this.value) + "'"; + } + return String.valueOf(this.value); + + default: + if (this.value instanceof byte[]) { + return "byte data"; + } + if (quoteIfNeeded) { + return "'" + String.valueOf(this.value) + "'"; + } + return String.valueOf(this.value); + } + } + + public long getBoundLength() { + if (this.isNull) { + return 0; + } + + if (this.isStream) { + return this.streamLength; + } + + switch (this.bufferType) { + + case MysqlType.FIELD_TYPE_TINY: + return 1; + case MysqlType.FIELD_TYPE_SHORT: + return 2; + case MysqlType.FIELD_TYPE_LONG: + return 4; + case MysqlType.FIELD_TYPE_LONGLONG: + return 8; + case MysqlType.FIELD_TYPE_FLOAT: + return 4; + case MysqlType.FIELD_TYPE_DOUBLE: + return 8; + case MysqlType.FIELD_TYPE_TIME: + return 9; + case MysqlType.FIELD_TYPE_DATE: + return 7; + case MysqlType.FIELD_TYPE_DATETIME: + case MysqlType.FIELD_TYPE_TIMESTAMP: + return 11; + case MysqlType.FIELD_TYPE_VAR_STRING: + case MysqlType.FIELD_TYPE_STRING: + case MysqlType.FIELD_TYPE_VARCHAR: + case MysqlType.FIELD_TYPE_DECIMAL: + case MysqlType.FIELD_TYPE_NEWDECIMAL: + if (this.value instanceof byte[]) { + return ((byte[]) this.value).length; + } + return ((String) this.value).length(); + + default: + return 0; + } + } + + public void storeBinding(NativePacketPayload intoPacket, boolean isLoadDataQuery, String characterEncoding, ExceptionInterceptor interceptor) { + synchronized (this) { + try { + // Handle primitives first + switch (this.bufferType) { + + case MysqlType.FIELD_TYPE_TINY: + intoPacket.writeInteger(IntegerDataType.INT1, ((Long) this.value).longValue()); + return; + case MysqlType.FIELD_TYPE_SHORT: + intoPacket.writeInteger(IntegerDataType.INT2, ((Long) this.value).longValue()); + return; + case MysqlType.FIELD_TYPE_LONG: + intoPacket.writeInteger(IntegerDataType.INT4, ((Long) this.value).longValue()); + return; + case MysqlType.FIELD_TYPE_LONGLONG: + intoPacket.writeInteger(IntegerDataType.INT8, ((Long) this.value).longValue()); + return; + case MysqlType.FIELD_TYPE_FLOAT: + intoPacket.writeInteger(IntegerDataType.INT4, Float.floatToIntBits(((Float) this.value).floatValue())); + return; + case MysqlType.FIELD_TYPE_DOUBLE: + intoPacket.writeInteger(IntegerDataType.INT8, Double.doubleToLongBits(((Double) this.value).doubleValue())); + return; + case MysqlType.FIELD_TYPE_TIME: + storeTime(intoPacket); + return; + case MysqlType.FIELD_TYPE_DATE: + storeDate(intoPacket); + return; + case MysqlType.FIELD_TYPE_DATETIME: + case MysqlType.FIELD_TYPE_TIMESTAMP: + storeDateTime(intoPacket, this.bufferType); + return; + case MysqlType.FIELD_TYPE_VAR_STRING: + case MysqlType.FIELD_TYPE_STRING: + case MysqlType.FIELD_TYPE_VARCHAR: + case MysqlType.FIELD_TYPE_DECIMAL: + case MysqlType.FIELD_TYPE_NEWDECIMAL: + if (this.value instanceof byte[]) { + intoPacket.writeBytes(StringSelfDataType.STRING_LENENC, (byte[]) this.value); + } else if (!isLoadDataQuery) { + intoPacket.writeBytes(StringSelfDataType.STRING_LENENC, StringUtils.getBytes((String) this.value, characterEncoding)); + } else { + intoPacket.writeBytes(StringSelfDataType.STRING_LENENC, StringUtils.getBytes((String) this.value)); + } + + return; + } + + } catch (CJException uEE) { + throw ExceptionFactory.createException(Messages.getString("ServerPreparedStatement.22") + characterEncoding + "'", uEE, interceptor); + } + } + } + + private void storeDate(NativePacketPayload intoPacket) { + synchronized (this) { + int year, month, day; + + if (this.value instanceof LocalDate) { + year = ((LocalDate) this.value).getYear(); + month = ((LocalDate) this.value).getMonthValue(); + day = ((LocalDate) this.value).getDayOfMonth(); + + } else if (this.value instanceof LocalTime) { + year = AbstractQueryBindings.DEFAULT_DATE.getYear(); + month = AbstractQueryBindings.DEFAULT_DATE.getMonthValue(); + day = AbstractQueryBindings.DEFAULT_DATE.getDayOfMonth(); + + } else if (this.value instanceof LocalDateTime) { + year = ((LocalDateTime) this.value).getYear(); + month = ((LocalDateTime) this.value).getMonthValue(); + day = ((LocalDateTime) this.value).getDayOfMonth(); + + } else { + if (this.calendar == null) { + this.calendar = Calendar.getInstance(this.cacheDefaultTimeZone.getValue() ? this.defaultTimeZone : TimeZone.getDefault(), Locale.US); + } + + this.calendar.setTime((java.util.Date) this.value); + + this.calendar.set(Calendar.HOUR_OF_DAY, 0); + this.calendar.set(Calendar.MINUTE, 0); + this.calendar.set(Calendar.SECOND, 0); + + year = this.calendar.get(Calendar.YEAR); + month = this.calendar.get(Calendar.MONTH) + 1; + day = this.calendar.get(Calendar.DAY_OF_MONTH); + } + + intoPacket.ensureCapacity(5); + intoPacket.writeInteger(IntegerDataType.INT1, 4); // length + intoPacket.writeInteger(IntegerDataType.INT2, year); + intoPacket.writeInteger(IntegerDataType.INT1, month); + intoPacket.writeInteger(IntegerDataType.INT1, day); + } + } + + private void storeTime(NativePacketPayload intoPacket) { + int neg = 0, days = 0, hours, minutes, seconds, microseconds; + + if (this.value instanceof LocalDateTime) { + hours = ((LocalDateTime) this.value).getHour(); + minutes = ((LocalDateTime) this.value).getMinute(); + seconds = ((LocalDateTime) this.value).getSecond(); + microseconds = ((LocalDateTime) this.value).getNano() / 1000; + } else if (this.value instanceof LocalTime) { + hours = ((LocalTime) this.value).getHour(); + minutes = ((LocalTime) this.value).getMinute(); + seconds = ((LocalTime) this.value).getSecond(); + microseconds = ((LocalTime) this.value).getNano() / 1000; + } else if (this.value instanceof Duration) { + neg = ((Duration) this.value).isNegative() ? 1 : 0; + long fullSeconds = ((Duration) this.value).abs().getSeconds(); + seconds = (int) (fullSeconds % 60); + long fullMinutes = fullSeconds / 60; + minutes = (int) (fullMinutes % 60); + long fullHours = fullMinutes / 60; + hours = (int) (fullHours % 24); + days = (int) (fullHours / 24); + microseconds = ((Duration) this.value).abs().getNano() / 1000; + } else { + if (this.calendar == null) { + this.calendar = Calendar.getInstance(this.defaultTimeZone, Locale.US); + } + + this.calendar.setTime((java.util.Date) this.value); + + hours = this.calendar.get(Calendar.HOUR_OF_DAY); + minutes = this.calendar.get(Calendar.MINUTE); + seconds = this.calendar.get(Calendar.SECOND); + microseconds = this.calendar.get(Calendar.MILLISECOND) * 1000; + } + + intoPacket.ensureCapacity(microseconds > 0 ? 13 : 9); + intoPacket.writeInteger(IntegerDataType.INT1, microseconds > 0 ? 12 : 8); // length + intoPacket.writeInteger(IntegerDataType.INT1, neg); + intoPacket.writeInteger(IntegerDataType.INT4, days); + intoPacket.writeInteger(IntegerDataType.INT1, hours); + intoPacket.writeInteger(IntegerDataType.INT1, minutes); + intoPacket.writeInteger(IntegerDataType.INT1, seconds); + if (microseconds > 0) { + intoPacket.writeInteger(IntegerDataType.INT4, microseconds); + } + } + + /** + * @param intoPacket + * packet to write into + * @param mysqlType + * MysqlType.FIELD_TYPE_* + */ + private void storeDateTime(NativePacketPayload intoPacket, int mysqlType) { + synchronized (this) { + + int year = 0, month = 0, day = 0, hours = 0, minutes = 0, seconds = 0, microseconds = 0; + + if (this.value instanceof LocalDate) { + year = ((LocalDate) this.value).getYear(); + month = ((LocalDate) this.value).getMonthValue(); + day = ((LocalDate) this.value).getDayOfMonth(); + + } else if (this.value instanceof LocalTime) { + year = AbstractQueryBindings.DEFAULT_DATE.getYear(); + month = AbstractQueryBindings.DEFAULT_DATE.getMonthValue(); + day = AbstractQueryBindings.DEFAULT_DATE.getDayOfMonth(); + hours = ((LocalTime) this.value).getHour(); + minutes = ((LocalTime) this.value).getMinute(); + seconds = ((LocalTime) this.value).getSecond(); + microseconds = ((LocalTime) this.value).getNano() / 1000; + + } else if (this.value instanceof LocalDateTime) { + year = ((LocalDateTime) this.value).getYear(); + month = ((LocalDateTime) this.value).getMonthValue(); + day = ((LocalDateTime) this.value).getDayOfMonth(); + hours = ((LocalDateTime) this.value).getHour(); + minutes = ((LocalDateTime) this.value).getMinute(); + seconds = ((LocalDateTime) this.value).getSecond(); + microseconds = ((LocalDateTime) this.value).getNano() / 1000; + + } else { + if (this.calendar == null) { + this.calendar = Calendar + .getInstance(mysqlType == MysqlType.FIELD_TYPE_TIMESTAMP && this.pset.getBooleanProperty(PropertyKey.preserveInstants).getValue() + ? this.connectionTimeZone + : this.defaultTimeZone, Locale.US); + } + + this.calendar.setTime((java.util.Date) this.value); + + if (this.value instanceof java.sql.Date) { + this.calendar.set(Calendar.HOUR_OF_DAY, 0); + this.calendar.set(Calendar.MINUTE, 0); + this.calendar.set(Calendar.SECOND, 0); + } + + year = this.calendar.get(Calendar.YEAR); + month = this.calendar.get(Calendar.MONTH) + 1; + day = this.calendar.get(Calendar.DAY_OF_MONTH); + hours = this.calendar.get(Calendar.HOUR_OF_DAY); + minutes = this.calendar.get(Calendar.MINUTE); + seconds = this.calendar.get(Calendar.SECOND); + + if (this.value instanceof java.sql.Timestamp) { + microseconds = ((java.sql.Timestamp) this.value).getNanos() / 1000; + } else { + microseconds = this.calendar.get(Calendar.MILLISECOND) * 1000; + } + } + + intoPacket.ensureCapacity(microseconds > 0 ? 12 : 8); + intoPacket.writeInteger(IntegerDataType.INT1, microseconds > 0 ? 11 : 7); // length + intoPacket.writeInteger(IntegerDataType.INT2, year); + intoPacket.writeInteger(IntegerDataType.INT1, month); + intoPacket.writeInteger(IntegerDataType.INT1, day); + intoPacket.writeInteger(IntegerDataType.INT1, hours); + intoPacket.writeInteger(IntegerDataType.INT1, minutes); + intoPacket.writeInteger(IntegerDataType.INT1, seconds); + if (microseconds > 0) { + intoPacket.writeInteger(IntegerDataType.INT4, microseconds); + } + } + } + + @Override + public byte[] getByteValue() { + if (!this.isStream) { + return this.charEncoding != null ? StringUtils.getBytes(toString(), this.charEncoding) : toString().getBytes(); + } + return null; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/ServerPreparedQueryBindings.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/ServerPreparedQueryBindings.java new file mode 100644 index 0000000..d239b02 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/ServerPreparedQueryBindings.java @@ -0,0 +1,602 @@ +/* + * Copyright (c) 2017, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.io.InputStream; +import java.io.Reader; +import java.math.BigDecimal; +import java.math.BigInteger; +import java.sql.Blob; +import java.sql.Clob; +import java.sql.Date; +import java.sql.NClob; +import java.sql.Time; +import java.sql.Timestamp; +import java.time.Duration; +import java.time.LocalDate; +import java.time.LocalDateTime; +import java.time.LocalTime; +import java.util.Calendar; +import java.util.concurrent.atomic.AtomicBoolean; + +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.WrongArgumentException; +import com.mysql.cj.util.StringUtils; +import com.mysql.cj.util.TimeUtil; + +//TODO should not be protocol-specific + +public class ServerPreparedQueryBindings extends AbstractQueryBindings { + + /** Do we need to send/resend types to the server? */ + private AtomicBoolean sendTypesToServer = new AtomicBoolean(false); + + /** + * Flag indicating whether or not the long parameters have been 'switched' back to normal parameters. + * We cannot execute() if clearParameters() has not been called in this case. + */ + private boolean longParameterSwitchDetected = false; + + public ServerPreparedQueryBindings(int parameterCount, Session sess) { + super(parameterCount, sess); + } + + @Override + protected void initBindValues(int parameterCount) { + this.bindValues = new ServerPreparedQueryBindValue[parameterCount]; + for (int i = 0; i < parameterCount; i++) { + this.bindValues[i] = new ServerPreparedQueryBindValue(this.session.getServerSession().getDefaultTimeZone(), + this.session.getServerSession().getSessionTimeZone(), this.session.getPropertySet()); + } + } + + @Override + public ServerPreparedQueryBindings clone() { + ServerPreparedQueryBindings newBindings = new ServerPreparedQueryBindings(this.bindValues.length, this.session); + ServerPreparedQueryBindValue[] bvs = new ServerPreparedQueryBindValue[this.bindValues.length]; + for (int i = 0; i < this.bindValues.length; i++) { + bvs[i] = this.bindValues[i].clone(); + } + newBindings.bindValues = bvs; + newBindings.sendTypesToServer = this.sendTypesToServer; + newBindings.longParameterSwitchDetected = this.longParameterSwitchDetected; + newBindings.isLoadDataQuery = this.isLoadDataQuery; + return newBindings; + } + + /** + * Returns the structure representing the value that (can be)/(is) + * bound at the given parameter index. + * + * @param parameterIndex + * 0-based + * @param forLongData + * is this for a stream? + * @return ServerPreparedQueryBindValue + */ + public ServerPreparedQueryBindValue getBinding(int parameterIndex, boolean forLongData) { + + if (this.bindValues[parameterIndex] == null) { + // this.bindValues[parameterIndex] = new ServerPreparedQueryBindValue(); + } else { + if (this.bindValues[parameterIndex].isStream && !forLongData) { + this.longParameterSwitchDetected = true; + } + } + + return this.bindValues[parameterIndex]; + } + + @Override + public void checkParameterSet(int columnIndex) { + if (!this.bindValues[columnIndex].isSet()) { + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("ServerPreparedStatement.13") + (columnIndex + 1) + Messages.getString("ServerPreparedStatement.14")); + } + } + + public AtomicBoolean getSendTypesToServer() { + return this.sendTypesToServer; + } + + public boolean isLongParameterSwitchDetected() { + return this.longParameterSwitchDetected; + } + + public void setLongParameterSwitchDetected(boolean longParameterSwitchDetected) { + this.longParameterSwitchDetected = longParameterSwitchDetected; + } + + @Override + public void setAsciiStream(int parameterIndex, InputStream x) { + setAsciiStream(parameterIndex, x, -1); + } + + @Override + public void setAsciiStream(int parameterIndex, InputStream x, int length) { + if (x == null) { + setNull(parameterIndex); + } else { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, true); + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_BLOB, this.numberOfExecutions)); + binding.value = x; + binding.isStream = true; + binding.streamLength = this.useStreamLengthsInPrepStmts.getValue() ? length : -1; + } + } + + @Override + public void setAsciiStream(int parameterIndex, InputStream x, long length) { + setAsciiStream(parameterIndex, x, (int) length); + this.bindValues[parameterIndex].setMysqlType(MysqlType.TEXT); // TODO was Types.CLOB, check; use length to find right TEXT type + } + + @Override + public void setBigDecimal(int parameterIndex, BigDecimal x) { + if (x == null) { + setNull(parameterIndex); + } else { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, false); + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_NEWDECIMAL, this.numberOfExecutions)); + binding.value = StringUtils.fixDecimalExponent(x.toPlainString()); + binding.parameterType = MysqlType.DECIMAL; + } + } + + @Override + public void setBigInteger(int parameterIndex, BigInteger x) { + setValue(parameterIndex, x.toString(), MysqlType.BIGINT_UNSIGNED); + } + + @Override + public void setBinaryStream(int parameterIndex, InputStream x) { + setBinaryStream(parameterIndex, x, -1); + } + + @Override + public void setBinaryStream(int parameterIndex, InputStream x, int length) { + if (x == null) { + setNull(parameterIndex); + } else { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, true); + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_BLOB, this.numberOfExecutions)); + binding.value = x; + binding.isStream = true; + binding.streamLength = this.useStreamLengthsInPrepStmts.getValue() ? length : -1; + binding.parameterType = MysqlType.BLOB; // TODO use length to find the right BLOB type + } + } + + @Override + public void setBinaryStream(int parameterIndex, InputStream x, long length) { + setBinaryStream(parameterIndex, x, (int) length); + } + + @Override + public void setBlob(int parameterIndex, InputStream inputStream) { + setBinaryStream(parameterIndex, inputStream); + } + + @Override + public void setBlob(int parameterIndex, InputStream inputStream, long length) { + setBinaryStream(parameterIndex, inputStream, (int) length); + } + + @Override + public void setBlob(int parameterIndex, Blob x) { + + if (x == null) { + setNull(parameterIndex); + } else { + try { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, true); + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_BLOB, this.numberOfExecutions)); + binding.value = x; + binding.isStream = true; + binding.streamLength = this.useStreamLengthsInPrepStmts.getValue() ? x.length() : -1; + binding.parameterType = MysqlType.BLOB; + } catch (Throwable t) { + throw ExceptionFactory.createException(t.getMessage(), t); + } + } + } + + @Override + public void setBoolean(int parameterIndex, boolean x) { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, false); + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_TINY, this.numberOfExecutions)); + binding.value = Long.valueOf(x ? (byte) 1 : (byte) 0); + binding.parameterType = MysqlType.BOOLEAN; + } + + @Override + public void setByte(int parameterIndex, byte x) { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, false); + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_TINY, this.numberOfExecutions)); + binding.value = Long.valueOf(x); + binding.parameterType = MysqlType.TINYINT; + } + + @Override + public void setBytes(int parameterIndex, byte[] x) { + if (x == null) { + setNull(parameterIndex); + } else { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, false); + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_VAR_STRING, this.numberOfExecutions)); + binding.value = x; + binding.parameterType = MysqlType.BINARY; // TODO VARBINARY ? + } + } + + @Override + public void setBytes(int parameterIndex, byte[] x, boolean checkForIntroducer, boolean escapeForMBChars) { + setBytes(parameterIndex, x); + } + + @Override + public void setBytesNoEscape(int parameterIndex, byte[] parameterAsBytes) { + setBytes(parameterIndex, parameterAsBytes); + } + + @Override + public void setBytesNoEscapeNoQuotes(int parameterIndex, byte[] parameterAsBytes) { + setBytes(parameterIndex, parameterAsBytes); + } + + @Override + public void setCharacterStream(int parameterIndex, Reader reader) { + setCharacterStream(parameterIndex, reader, -1); + } + + @Override + public void setCharacterStream(int parameterIndex, Reader reader, int length) { + if (reader == null) { + setNull(parameterIndex); + } else { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, true); + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_BLOB, this.numberOfExecutions)); + binding.value = reader; + binding.isStream = true; + binding.streamLength = this.useStreamLengthsInPrepStmts.getValue() ? length : -1; + binding.parameterType = MysqlType.TEXT; + } + } + + @Override + public void setCharacterStream(int parameterIndex, Reader reader, long length) { + setCharacterStream(parameterIndex, reader, (int) length); + } + + @Override + public void setClob(int parameterIndex, Reader reader) { + setCharacterStream(parameterIndex, reader); + } + + @Override + public void setClob(int parameterIndex, Reader reader, long length) { + setCharacterStream(parameterIndex, reader, length); + } + + @Override + public void setClob(int parameterIndex, Clob x) { + if (x == null) { + setNull(parameterIndex); + } else { + try { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, true); + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_BLOB, this.numberOfExecutions)); + binding.value = x.getCharacterStream(); + binding.isStream = true; + binding.streamLength = this.useStreamLengthsInPrepStmts.getValue() ? x.length() : -1; + binding.parameterType = MysqlType.TEXT; + } catch (Throwable t) { + throw ExceptionFactory.createException(t.getMessage(), t); + } + } + } + + @Override + public void setDate(int parameterIndex, Date x) { + setDate(parameterIndex, x, null); + } + + @Override + public void setDate(int parameterIndex, Date x, Calendar cal) { + if (x == null) { + setNull(parameterIndex); + } else { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, false); + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_DATE, this.numberOfExecutions)); + binding.value = x; + binding.calendar = cal == null ? null : (Calendar) cal.clone(); + binding.parameterType = MysqlType.DATE; + } + } + + @Override + public void setDouble(int parameterIndex, double x) { + if (!this.session.getPropertySet().getBooleanProperty(PropertyKey.allowNanAndInf).getValue() + && (x == Double.POSITIVE_INFINITY || x == Double.NEGATIVE_INFINITY || Double.isNaN(x))) { + throw ExceptionFactory.createException(WrongArgumentException.class, Messages.getString("PreparedStatement.64", new Object[] { x }), + this.session.getExceptionInterceptor()); + } + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, false); + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_DOUBLE, this.numberOfExecutions)); + binding.value = Double.valueOf(x); + binding.parameterType = MysqlType.DOUBLE; + } + + @Override + public void setFloat(int parameterIndex, float x) { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, false); + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_FLOAT, this.numberOfExecutions)); + binding.value = Float.valueOf(x); + binding.parameterType = MysqlType.FLOAT; // TODO check; was Types.FLOAT but should be Types.REAL to map to SQL FLOAT + } + + @Override + public void setInt(int parameterIndex, int x) { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, false); + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_LONG, this.numberOfExecutions)); + binding.value = Long.valueOf(x); + binding.parameterType = MysqlType.INT; + } + + @Override + public void setLocalDate(int parameterIndex, LocalDate x, MysqlType targetMysqlType) { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, false); + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_DATE, this.numberOfExecutions)); + binding.parameterType = targetMysqlType; + binding.value = x; + } + + @Override + public void setLocalTime(int parameterIndex, LocalTime x, MysqlType targetMysqlType) { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, false); + if (targetMysqlType == MysqlType.DATE) { + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_DATE, this.numberOfExecutions)); + binding.parameterType = targetMysqlType; + binding.value = DEFAULT_DATE; + return; + } + + if (!this.session.getServerSession().getCapabilities().serverSupportsFracSecs() || !this.sendFractionalSeconds.getValue()) { + if (x.getNano() > 0) { + x = x.withNano(0); // truncate nanoseconds + } + } else { + int fractLen = 6; // max supported length (i.e. microsecond) + if (this.columnDefinition != null && parameterIndex <= this.columnDefinition.getFields().length && parameterIndex >= 0) { + // use the column definition if available + fractLen = this.columnDefinition.getFields()[parameterIndex].getDecimals(); + } + x = TimeUtil.adjustNanosPrecision(x, fractLen, !this.session.getServerSession().isServerTruncatesFracSecs()); + } + + if (targetMysqlType == MysqlType.TIME) { + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_TIME, this.numberOfExecutions)); + } else { + // DATETIME or TIMESTAMP + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_DATETIME, this.numberOfExecutions)); + } + binding.parameterType = targetMysqlType; + binding.value = x; + } + + @Override + public void setLocalDateTime(int parameterIndex, LocalDateTime x, MysqlType targetMysqlType) { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, false); + if (targetMysqlType == MysqlType.DATE) { + x = LocalDateTime.of(x.toLocalDate(), DEFAULT_TIME); + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_DATE, this.numberOfExecutions)); + } else { + int fractLen = 6; // max supported length (i.e. microsecond) + if (this.columnDefinition != null && parameterIndex <= this.columnDefinition.getFields().length && parameterIndex >= 0) { + // use the column definition if available + fractLen = this.columnDefinition.getFields()[parameterIndex].getDecimals(); + } + + if (!this.session.getServerSession().getCapabilities().serverSupportsFracSecs() || !this.sendFractionalSeconds.getValue()) { + if (x.getNano() > 0) { + x = x.withNano(0); // truncate nanoseconds + } + } else { + x = TimeUtil.adjustNanosPrecision(x, fractLen, !this.session.getServerSession().isServerTruncatesFracSecs()); + } + + if (targetMysqlType == MysqlType.TIME) { + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_TIME, this.numberOfExecutions)); + } else { + // DATETIME or TIMESTAMP + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_DATETIME, this.numberOfExecutions)); + } + } + binding.parameterType = targetMysqlType; + binding.value = x; + } + + @Override + public void setLong(int parameterIndex, long x) { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, false); + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_LONGLONG, this.numberOfExecutions)); + binding.value = Long.valueOf(x); + binding.parameterType = MysqlType.BIGINT; + } + + @Override + public void setNCharacterStream(int parameterIndex, Reader value) { + setNCharacterStream(parameterIndex, value, -1); + } + + @Override + public void setNCharacterStream(int parameterIndex, Reader reader, long length) { + if (!this.charEncoding.equalsIgnoreCase("UTF-8") && !this.charEncoding.equalsIgnoreCase("utf8")) { + throw ExceptionFactory.createException(Messages.getString("ServerPreparedStatement.28"), this.session.getExceptionInterceptor()); + } + + if (reader == null) { + setNull(parameterIndex); + } else { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, true); + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_BLOB, this.numberOfExecutions)); + binding.value = reader; + binding.isStream = true; + binding.streamLength = this.useStreamLengthsInPrepStmts.getValue() ? length : -1; + binding.parameterType = MysqlType.TEXT; + } + } + + @Override + public void setNClob(int parameterIndex, Reader reader) { + setNCharacterStream(parameterIndex, reader); + } + + @Override + public void setNClob(int parameterIndex, Reader reader, long length) { + if (!this.charEncoding.equalsIgnoreCase("UTF-8") && !this.charEncoding.equalsIgnoreCase("utf8")) { + throw ExceptionFactory.createException(Messages.getString("ServerPreparedStatement.29"), this.session.getExceptionInterceptor()); + } + setNCharacterStream(parameterIndex, reader, length); + } + + @Override + public void setNClob(int parameterIndex, NClob value) { + try { + setNClob(parameterIndex, value.getCharacterStream(), this.useStreamLengthsInPrepStmts.getValue() ? value.length() : -1); + } catch (Throwable t) { + throw ExceptionFactory.createException(t.getMessage(), t, this.session.getExceptionInterceptor()); + } + } + + @Override + public void setNString(int parameterIndex, String x) { + if (this.charEncoding.equalsIgnoreCase("UTF-8") || this.charEncoding.equalsIgnoreCase("utf8")) { + setString(parameterIndex, x); + } else { + throw ExceptionFactory.createException(Messages.getString("ServerPreparedStatement.30"), this.session.getExceptionInterceptor()); + } + } + + @Override + public void setNull(int parameterIndex) { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, false); + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_NULL, this.numberOfExecutions)); + binding.setNull(true); + } + + @Override + public void setShort(int parameterIndex, short x) { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, false); + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_SHORT, this.numberOfExecutions)); + binding.value = Long.valueOf(x); + binding.parameterType = MysqlType.SMALLINT; + } + + @Override + public void setString(int parameterIndex, String x) { + if (x == null) { + setNull(parameterIndex); + } else { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, false); + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_VAR_STRING, this.numberOfExecutions)); + binding.value = x; + binding.charEncoding = this.charEncoding; + binding.parameterType = MysqlType.VARCHAR; + } + } + + public void setTime(int parameterIndex, Time x, Calendar cal) { + if (x == null) { + setNull(parameterIndex); + } else { + if (!this.session.getServerSession().getCapabilities().serverSupportsFracSecs() || !this.sendFractionalSeconds.getValue() + || !this.sendFractionalSecondsForTime.getValue()) { + x = TimeUtil.truncateFractionalSeconds(x); + } + + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, false); + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_TIME, this.numberOfExecutions)); + binding.value = x; + binding.calendar = cal == null ? null : (Calendar) cal.clone(); + binding.parameterType = MysqlType.TIME; + } + } + + public void setTime(int parameterIndex, Time x) { + setTime(parameterIndex, x, null); + } + + @Override + public void bindTimestamp(int parameterIndex, Timestamp x, Calendar targetCalendar, int fractionalLength, MysqlType targetMysqlType) { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, false); + this.sendTypesToServer.compareAndSet(false, binding + .resetToType(targetMysqlType == MysqlType.TIMESTAMP ? MysqlType.FIELD_TYPE_TIMESTAMP : MysqlType.FIELD_TYPE_DATETIME, this.numberOfExecutions)); + + if (fractionalLength < 0) { + // default to 6 fractional positions + fractionalLength = 6; + } + + x = TimeUtil.adjustNanosPrecision(x, fractionalLength, !this.session.getServerSession().isServerTruncatesFracSecs()); + + binding.value = x; + binding.calendar = targetCalendar == null ? null : (Calendar) targetCalendar.clone(); + binding.parameterType = targetMysqlType; + + } + + @Override + public void setDuration(int parameterIndex, Duration x, MysqlType targetMysqlType) { + ServerPreparedQueryBindValue binding = getBinding(parameterIndex, false); + if (!this.session.getServerSession().getCapabilities().serverSupportsFracSecs() || !this.sendFractionalSeconds.getValue()) { + if (x.getNano() > 0) { + x = x.isNegative() ? x.plusSeconds(1).withNanos(0) : x.withNanos(0); // truncate nanoseconds + } + } else { + int fractLen = 6; // max supported length (i.e. microsecond) + if (this.columnDefinition != null && parameterIndex <= this.columnDefinition.getFields().length && parameterIndex >= 0) { + // use the column definition if available + fractLen = this.columnDefinition.getFields()[parameterIndex].getDecimals(); + } + x = TimeUtil.adjustNanosPrecision(x, fractLen, !this.session.getServerSession().isServerTruncatesFracSecs()); + } + + if (targetMysqlType == MysqlType.TIME) { + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_TIME, this.numberOfExecutions)); + } else { + // DATETIME or TIMESTAMP + this.sendTypesToServer.compareAndSet(false, binding.resetToType(MysqlType.FIELD_TYPE_DATETIME, this.numberOfExecutions)); + } + binding.parameterType = targetMysqlType; + binding.value = x; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/ServerPreparedQueryTestcaseGenerator.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/ServerPreparedQueryTestcaseGenerator.java new file mode 100644 index 0000000..10ef432 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/ServerPreparedQueryTestcaseGenerator.java @@ -0,0 +1,133 @@ +/* + * Copyright (c) 2017, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +import java.io.IOException; + +import com.mysql.cj.protocol.ColumnDefinition; +import com.mysql.cj.protocol.ProtocolEntityFactory; +import com.mysql.cj.protocol.Resultset; +import com.mysql.cj.protocol.a.NativePacketPayload; +import com.mysql.cj.util.TestUtils; + +//TODO should not be protocol-specific + +public class ServerPreparedQueryTestcaseGenerator extends ServerPreparedQuery { + + public ServerPreparedQueryTestcaseGenerator(NativeSession sess) { + super(sess); + } + + @Override + public void closeQuery() { + dumpCloseForTestcase(); + super.closeQuery(); + } + + private void dumpCloseForTestcase() { + StringBuilder buf = new StringBuilder(); + this.session.getProtocol().generateQueryCommentBlock(buf); + buf.append("DEALLOCATE PREPARE debug_stmt_"); + buf.append(this.statementId); + buf.append(";\n"); + + TestUtils.dumpTestcaseQuery(buf.toString()); + } + + @Override + public void serverPrepare(String sql) throws IOException { + dumpPrepareForTestcase(); + super.serverPrepare(sql); + } + + private void dumpPrepareForTestcase() { + StringBuilder buf = new StringBuilder(this.getOriginalSql().length() + 64); + + this.session.getProtocol().generateQueryCommentBlock(buf); + + buf.append("PREPARE debug_stmt_"); + buf.append(this.statementId); + buf.append(" FROM \""); + buf.append(this.getOriginalSql()); + buf.append("\";\n"); + + TestUtils.dumpTestcaseQuery(buf.toString()); + } + + @Override + public T serverExecute(int maxRowsToRetrieve, boolean createStreamingResultSet, ColumnDefinition metadata, + ProtocolEntityFactory resultSetFactory) { + dumpExecuteForTestcase(); + return super.serverExecute(maxRowsToRetrieve, createStreamingResultSet, metadata, resultSetFactory); + } + + private void dumpExecuteForTestcase() { + StringBuilder buf = new StringBuilder(); + + for (int i = 0; i < this.getParameterCount(); i++) { + this.session.getProtocol().generateQueryCommentBlock(buf); + + buf.append("SET @debug_stmt_param"); + buf.append(this.statementId); + buf.append("_"); + buf.append(i); + buf.append("="); + + ServerPreparedQueryBindValue bv = this.queryBindings.getBindValues()[i]; + buf.append(bv.isNull() ? "NULL" : bv.toString(true)); + + buf.append(";\n"); + } + + this.session.getProtocol().generateQueryCommentBlock(buf); + + buf.append("EXECUTE debug_stmt_"); + buf.append(this.statementId); + + if (this.getParameterCount() > 0) { + buf.append(" USING "); + for (int i = 0; i < this.getParameterCount(); i++) { + if (i > 0) { + buf.append(", "); + } + + buf.append("@debug_stmt_param"); + buf.append(this.statementId); + buf.append("_"); + buf.append(i); + + } + } + + buf.append(";\n"); + + TestUtils.dumpTestcaseQuery(buf.toString()); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/SimpleQuery.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/SimpleQuery.java new file mode 100644 index 0000000..b84fc91 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/SimpleQuery.java @@ -0,0 +1,40 @@ +/* + * Copyright (c) 2017, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj; + +//TODO should not be protocol-specific + +public class SimpleQuery extends AbstractQuery { + + public SimpleQuery(NativeSession sess) { + super(sess); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/admin/ServerController.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/admin/ServerController.java new file mode 100644 index 0000000..0573655 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/admin/ServerController.java @@ -0,0 +1,333 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.admin; + +import java.io.File; +import java.io.IOException; +import java.util.Iterator; +import java.util.Properties; + +import com.mysql.cj.Constants; +import com.mysql.cj.util.StringUtils; + +/** + * Controls a MySQL server using Java RunTime methods + */ +public class ServerController { + + /** + * Where is the server installed? + */ + public static final String BASEDIR_KEY = "basedir"; + + /** + * Where are the databases installed? + */ + public static final String DATADIR_KEY = "datadir"; + + /** + * Where is the config file located? + */ + + public static final String DEFAULTS_FILE_KEY = "defaults-file"; + + /** + * What is the name of the executable to run? + */ + + public static final String EXECUTABLE_NAME_KEY = "executable"; + + /** + * What is the path to the mysql server executable (if not standard?) + */ + + public static final String EXECUTABLE_PATH_KEY = "executablePath"; + + /** + * The default executable to run + */ + + /** + * The process representing the MySQL server + */ + private Process serverProcess = null; + + /** + * The list of properties for this server + */ + private Properties serverProps = null; + + /** + * The system properties + */ + //private Properties systemProps = null; + + /** + * Creates a ServerController with the directory for the MySQL server. + * + * The 'datadir' is set to the same directory. + * + * @param baseDir + * the base directory for the MySQL server. + */ + public ServerController(String baseDir) { + setBaseDir(baseDir); + } + + /** + * Creates a server controller for the MySQL server with the given basedir + * and datadir. + * + * @param basedir + * the basedir to use when starting MySQL. + * @param datadir + * the datadir to use when starting MySQL. + */ + public ServerController(String basedir, String datadir) { + } + + /** + * Sets the basedir to use when starting MySQL. + * + * @param baseDir + * the basedir to use when starting MySQL. + */ + public void setBaseDir(String baseDir) { + getServerProps().setProperty(BASEDIR_KEY, baseDir); + } + + /** + * Sets the data to use when starting MySQL. + * + * @param dataDir + * the basedir to use when starting MySQL. + */ + public void setDataDir(String dataDir) { + getServerProps().setProperty(DATADIR_KEY, dataDir); + } + + /** + * Starts the server, returning a java.lang.Process instance that represents + * the mysql server. + * + * @return Process a java.lang.Process instance representing the mysql + * server process. + * @throws IOException + * if an error occurs while starting the mysql server. + */ + public Process start() throws IOException { + if (this.serverProcess != null) { + throw new IllegalArgumentException("Server already started"); + } + this.serverProcess = Runtime.getRuntime().exec(getCommandLine()); + + return this.serverProcess; + } + + /** + * Stops the server (if started) + * + * @param forceIfNecessary + * use forceStop if mysqladmin doesn't shut the server down + * + * @throws IOException + * if an error occurs while stopping the server + */ + public void stop(boolean forceIfNecessary) throws IOException { + if (this.serverProcess != null) { + + String basedir = getServerProps().getProperty(BASEDIR_KEY); + + StringBuilder pathBuf = new StringBuilder(basedir); + + if (!basedir.endsWith(File.separator)) { + pathBuf.append(File.separator); + } + + //String defaultsFilePath = getServerProps().getProperty(DEFAULTS_FILE_KEY); + + pathBuf.append("bin"); + pathBuf.append(File.separator); + pathBuf.append("mysqladmin shutdown"); + + System.out.println(pathBuf.toString()); + + Process mysqladmin = Runtime.getRuntime().exec(pathBuf.toString()); + + int exitStatus = -1; + + try { + exitStatus = mysqladmin.waitFor(); + } catch (InterruptedException ie) { + // ignore + } + + // + // Terminate the process if mysqladmin couldn't do it, and the user requested a force stop. + // + if (exitStatus != 0 && forceIfNecessary) { + forceStop(); + } + } + } + + /** + * Forcefully terminates the server process (if started). + */ + public void forceStop() { + if (this.serverProcess != null) { + this.serverProcess.destroy(); + this.serverProcess = null; + } + } + + /** + * Returns the list of properties that will be used to start/control the + * server. + * + * @return Properties the list of properties. + */ + public synchronized Properties getServerProps() { + if (this.serverProps == null) { + this.serverProps = new Properties(); + } + + return this.serverProps; + } + + /** + * Returns the full commandline used to start the mysql server, including + * and arguments to be passed to the server process. + * + * @return String the commandline used to start the mysql server. + */ + private String getCommandLine() { + StringBuilder commandLine = new StringBuilder(getFullExecutablePath()); + commandLine.append(buildOptionalCommandLine()); + + return commandLine.toString(); + } + + /** + * Returns the fully-qualifed path to the 'mysqld' executable + * + * @return String the path to the server executable. + */ + private String getFullExecutablePath() { + StringBuilder pathBuf = new StringBuilder(); + + String optionalExecutablePath = getServerProps().getProperty(EXECUTABLE_PATH_KEY); + + if (optionalExecutablePath == null) { + // build the path using the defaults + String basedir = getServerProps().getProperty(BASEDIR_KEY); + pathBuf.append(basedir); + + if (!basedir.endsWith(File.separator)) { + pathBuf.append(File.separatorChar); + } + + if (runningOnWindows()) { + pathBuf.append("bin"); + } else { + pathBuf.append("libexec"); + } + + pathBuf.append(File.separatorChar); + } else { + pathBuf.append(optionalExecutablePath); + + if (!optionalExecutablePath.endsWith(File.separator)) { + pathBuf.append(File.separatorChar); + } + } + + String executableName = getServerProps().getProperty(EXECUTABLE_NAME_KEY, "mysqld"); + + pathBuf.append(executableName); + + return pathBuf.toString(); + } + + /** + * Builds the list of command-line arguments that will be passed to the + * mysql server to be started. + * + * @return String the list of command-line arguments. + */ + private String buildOptionalCommandLine() { + StringBuilder commandLineBuf = new StringBuilder(); + + if (this.serverProps != null) { + + for (Iterator iter = this.serverProps.keySet().iterator(); iter.hasNext();) { + String key = (String) iter.next(); + String value = this.serverProps.getProperty(key); + + if (!isNonCommandLineArgument(key)) { + if (value != null && value.length() > 0) { + commandLineBuf.append(" \""); + commandLineBuf.append("--"); + commandLineBuf.append(key); + commandLineBuf.append("="); + commandLineBuf.append(value); + commandLineBuf.append("\""); + } else { + commandLineBuf.append(" --"); + commandLineBuf.append(key); + } + } + } + } + + return commandLineBuf.toString(); + } + + /** + * Returns true if the property does not belong as a command-line argument + * + * @param propName + * property name + * + * @return boolean if the property should not be a command-line argument. + */ + private boolean isNonCommandLineArgument(String propName) { + return propName.equals(EXECUTABLE_NAME_KEY) || propName.equals(EXECUTABLE_PATH_KEY); + } + + /** + * Is this ServerController running on a Windows operating system? + * + * @return boolean if this ServerController is running on Windows + */ + private boolean runningOnWindows() { + return StringUtils.indexOfIgnoreCase(Constants.OS_NAME, "WINDOWS") != -1; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/AbstractPropertyDefinition.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/AbstractPropertyDefinition.java new file mode 100644 index 0000000..eb62d92 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/AbstractPropertyDefinition.java @@ -0,0 +1,183 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +import java.io.Serializable; + +import com.mysql.cj.exceptions.ExceptionInterceptor; + +public abstract class AbstractPropertyDefinition implements PropertyDefinition, Serializable { + + private static final long serialVersionUID = 2696624840927848766L; + + private PropertyKey key = null; + private String name; + private String ccAlias; + private T defaultValue; + private boolean isRuntimeModifiable; + private String description; + private String sinceVersion; + private String category; + private int order; + + private int lowerBound; + private int upperBound; + + public AbstractPropertyDefinition(String name, String camelCaseAlias, T defaultValue, boolean isRuntimeModifiable, String description, String sinceVersion, + String category, int orderInCategory) { + + this.name = name; + this.ccAlias = camelCaseAlias; + this.setDefaultValue(defaultValue); + this.setRuntimeModifiable(isRuntimeModifiable); + this.setDescription(description); + this.setSinceVersion(sinceVersion); + this.setCategory(category); + this.setOrder(orderInCategory); + } + + public AbstractPropertyDefinition(PropertyKey key, T defaultValue, boolean isRuntimeModifiable, String description, String sinceVersion, String category, + int orderInCategory) { + + this.key = key; + this.name = key.getKeyName(); + this.ccAlias = key.getCcAlias(); + this.setDefaultValue(defaultValue); + this.setRuntimeModifiable(isRuntimeModifiable); + this.setDescription(description); + this.setSinceVersion(sinceVersion); + this.setCategory(category); + this.setOrder(orderInCategory); + } + + public AbstractPropertyDefinition(PropertyKey key, T defaultValue, boolean isRuntimeModifiable, String description, String sinceVersion, String category, + int orderInCategory, int lowerBound, int upperBound) { + this(key, defaultValue, isRuntimeModifiable, description, sinceVersion, category, orderInCategory); + this.setLowerBound(lowerBound); + this.setUpperBound(upperBound); + } + + public boolean hasValueConstraints() { + return (getAllowableValues() != null) && (getAllowableValues().length > 0); + } + + public boolean isRangeBased() { + return false; + } + + @Override + public PropertyKey getPropertyKey() { + return this.key; + } + + public String getName() { + return this.name; + } + + @Override + public String getCcAlias() { + return this.ccAlias; + } + + @Override + public boolean hasCcAlias() { + return this.ccAlias != null && this.ccAlias.length() > 0; + } + + public T getDefaultValue() { + return this.defaultValue; + } + + public void setDefaultValue(T defaultValue) { + this.defaultValue = defaultValue; + } + + public boolean isRuntimeModifiable() { + return this.isRuntimeModifiable; + } + + public void setRuntimeModifiable(boolean isRuntimeModifiable) { + this.isRuntimeModifiable = isRuntimeModifiable; + } + + public String getDescription() { + return this.description; + } + + public void setDescription(String description) { + this.description = description; + } + + public String getSinceVersion() { + return this.sinceVersion; + } + + public void setSinceVersion(String sinceVersion) { + this.sinceVersion = sinceVersion; + } + + public String getCategory() { + return this.category; + } + + public void setCategory(String category) { + this.category = category; + } + + public int getOrder() { + return this.order; + } + + public void setOrder(int order) { + this.order = order; + } + + public String[] getAllowableValues() { + return null; + } + + public int getLowerBound() { + return this.lowerBound; + } + + public void setLowerBound(int lowerBound) { + this.lowerBound = lowerBound; + } + + public int getUpperBound() { + return this.upperBound; + } + + public void setUpperBound(int upperBound) { + this.upperBound = upperBound; + } + + public abstract T parseObject(String value, ExceptionInterceptor exceptionInterceptor); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/AbstractRuntimeProperty.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/AbstractRuntimeProperty.java new file mode 100644 index 0000000..88e2e6a --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/AbstractRuntimeProperty.java @@ -0,0 +1,234 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +import java.io.Serializable; +import java.lang.ref.WeakReference; +import java.util.ArrayList; +import java.util.List; +import java.util.Properties; + +import javax.naming.RefAddr; +import javax.naming.Reference; + +import com.mysql.cj.Messages; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.ExceptionInterceptor; +import com.mysql.cj.exceptions.PropertyNotModifiableException; + +public abstract class AbstractRuntimeProperty implements RuntimeProperty, Serializable { + + private static final long serialVersionUID = -3424722534876438236L; + + private PropertyDefinition propertyDefinition; + + protected T value; + + protected T initialValue; + + protected boolean wasExplicitlySet = false; + + private List> listeners; + + public AbstractRuntimeProperty() { + } + + protected AbstractRuntimeProperty(PropertyDefinition propertyDefinition) { + this.propertyDefinition = propertyDefinition; + this.value = propertyDefinition.getDefaultValue(); + this.initialValue = propertyDefinition.getDefaultValue(); + } + + @Override + public PropertyDefinition getPropertyDefinition() { + return this.propertyDefinition; + } + + @Override + public void initializeFrom(Properties extractFrom, ExceptionInterceptor exceptionInterceptor) { + String name = getPropertyDefinition().getName(); + String alias = getPropertyDefinition().getCcAlias(); + if (extractFrom.containsKey(name)) { + String extractedValue = (String) extractFrom.remove(name); + if (extractedValue != null) { + setValueInternal(extractedValue, exceptionInterceptor); + this.initialValue = this.value; + } + } else if (alias != null && extractFrom.containsKey(alias)) { + String extractedValue = (String) extractFrom.remove(alias); + if (extractedValue != null) { + setValueInternal(extractedValue, exceptionInterceptor); + this.initialValue = this.value; + } + } + } + + @Override + public void initializeFrom(Reference ref, ExceptionInterceptor exceptionInterceptor) { + RefAddr refAddr = ref.get(getPropertyDefinition().getName()); + if (refAddr != null) { + String refContentAsString = (String) refAddr.getContent(); + if (refContentAsString != null) { + setValueInternal(refContentAsString, exceptionInterceptor); + this.initialValue = this.value; + } + } + } + + @Override + public void resetValue() { + this.value = this.initialValue; + invokeListeners(); + } + + public boolean isExplicitlySet() { + return this.wasExplicitlySet; + } + + @Override + public void addListener(RuntimePropertyListener l) { + if (this.listeners == null) { + this.listeners = new ArrayList<>(); + } + + boolean found = false; + for (WeakReference weakReference : this.listeners) { + if (l.equals(weakReference.get())) { + found = true; + break; + } + } + if (!found) { + this.listeners.add(new WeakReference<>(l)); + } + } + + @Override + public void removeListener(RuntimePropertyListener listener) { + if (this.listeners != null) { + for (WeakReference wr : this.listeners) { + RuntimePropertyListener l = wr.get(); + if (l.equals(listener)) { + this.listeners.remove(wr); + break; + } + } + } + } + + protected void invokeListeners() { + if (this.listeners != null) { + for (WeakReference wr : this.listeners) { + RuntimePropertyListener l = wr.get(); + if (l != null) { + l.handlePropertyChange(this); + } else { + this.listeners.remove(wr); + } + } + } + } + + @Override + public T getValue() { + return this.value; + } + + @Override + public T getInitialValue() { + return this.initialValue; + } + + @Override + public String getStringValue() { + return this.value == null ? null : this.value.toString(); + } + + /** + * Set the value of a property from a string value. + * It involves the {@link PropertyDefinition#parseObject(String, ExceptionInterceptor)} to validate and parse the string. + * + * @param value + * value + * @param exceptionInterceptor + * exception interceptor + */ + public void setValueInternal(String value, ExceptionInterceptor exceptionInterceptor) { + setValueInternal(getPropertyDefinition().parseObject(value, exceptionInterceptor), value, exceptionInterceptor); + } + + /** + * Internal method for setting property value; ignoring the RUNTIME_NOT_MODIFIABLE flag. + * + * @param value + * value + * @param valueAsString + * value represented by String + * @param exceptionInterceptor + * exception interceptor + */ + public void setValueInternal(T value, String valueAsString, ExceptionInterceptor exceptionInterceptor) { + if (getPropertyDefinition().isRangeBased()) { + checkRange(value, valueAsString, exceptionInterceptor); + } + this.value = value; + this.wasExplicitlySet = true; + } + + /** + * For range-based property, checks that value fit into range given by PropertyDefinition. + * + * @param val + * value + * @param valueAsString + * value represented by String + * @param exceptionInterceptor + * exception interceptor + */ + protected void checkRange(T val, String valueAsString, ExceptionInterceptor exceptionInterceptor) { + // no-op for not range-based properties + } + + @Override + public void setValue(T value) { + setValue(value, null); + } + + @Override + public void setValue(T value, ExceptionInterceptor exceptionInterceptor) { + if (getPropertyDefinition().isRuntimeModifiable()) { + setValueInternal(value, null, exceptionInterceptor); + invokeListeners(); + } else { + throw ExceptionFactory.createException(PropertyNotModifiableException.class, + Messages.getString("ConnectionProperties.dynamicChangeIsNotAllowed", new Object[] { "'" + getPropertyDefinition().getName() + "'" })); + } + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/BooleanProperty.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/BooleanProperty.java new file mode 100644 index 0000000..f2b5f6b --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/BooleanProperty.java @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +public class BooleanProperty extends AbstractRuntimeProperty { + + private static final long serialVersionUID = 1102859411443650569L; + + protected BooleanProperty(PropertyDefinition propertyDefinition) { + super(propertyDefinition); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/BooleanPropertyDefinition.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/BooleanPropertyDefinition.java new file mode 100644 index 0000000..cea8b2a --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/BooleanPropertyDefinition.java @@ -0,0 +1,97 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +import java.util.Arrays; + +import com.mysql.cj.Messages; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.ExceptionInterceptor; +import com.mysql.cj.util.StringUtils; + +public class BooleanPropertyDefinition extends AbstractPropertyDefinition { + + private static final long serialVersionUID = -7288366734350231540L; + + public enum AllowableValues { + TRUE(true), FALSE(false), YES(true), NO(false); + + private boolean asBoolean; + + private AllowableValues(boolean booleanValue) { + this.asBoolean = booleanValue; + } + + public boolean asBoolean() { + return this.asBoolean; + } + } + + public BooleanPropertyDefinition(PropertyKey key, Boolean defaultValue, boolean isRuntimeModifiable, String description, String sinceVersion, + String category, int orderInCategory) { + super(key, defaultValue, isRuntimeModifiable, description, sinceVersion, category, orderInCategory); + } + + @Override + public String[] getAllowableValues() { + return getBooleanAllowableValues(); + } + + @Override + public Boolean parseObject(String value, ExceptionInterceptor exceptionInterceptor) { + return booleanFrom(getName(), value, exceptionInterceptor); + } + + /** + * Creates instance of BooleanProperty. + * + * @return RuntimeProperty + */ + @Override + public RuntimeProperty createRuntimeProperty() { + return new BooleanProperty(this); + } + + public static Boolean booleanFrom(String name, String value, ExceptionInterceptor exceptionInterceptor) { + try { + return AllowableValues.valueOf(value.toUpperCase()).asBoolean(); + } catch (Exception e) { + throw ExceptionFactory.createException( + Messages.getString("PropertyDefinition.1", + new Object[] { name, StringUtils.stringArrayToString(getBooleanAllowableValues(), "'", "', '", "' or '", "'"), value }), + e, exceptionInterceptor); + } + } + + public static String[] getBooleanAllowableValues() { + return Arrays.stream(AllowableValues.values()).map(AllowableValues::toString).toArray(String[]::new); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/DefaultPropertySet.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/DefaultPropertySet.java new file mode 100644 index 0000000..f32520c --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/DefaultPropertySet.java @@ -0,0 +1,271 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +import java.io.Serializable; +import java.util.HashMap; +import java.util.Map; +import java.util.Properties; + +import com.mysql.cj.Messages; +import com.mysql.cj.conf.PropertyDefinitions.SslMode; +import com.mysql.cj.exceptions.CJException; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.WrongArgumentException; + +public class DefaultPropertySet implements PropertySet, Serializable { + + private static final long serialVersionUID = -5156024634430650528L; + + private final Map> PROPERTY_KEY_TO_RUNTIME_PROPERTY = new HashMap<>(); + private final Map> PROPERTY_NAME_TO_RUNTIME_PROPERTY = new HashMap<>(); + + public DefaultPropertySet() { + for (PropertyDefinition pdef : PropertyDefinitions.PROPERTY_KEY_TO_PROPERTY_DEFINITION.values()) { + addProperty(pdef.createRuntimeProperty()); + } + } + + @Override + public void addProperty(RuntimeProperty prop) { + PropertyDefinition def = prop.getPropertyDefinition(); + if (def.getPropertyKey() != null) { + this.PROPERTY_KEY_TO_RUNTIME_PROPERTY.put(def.getPropertyKey(), prop); + } else { + this.PROPERTY_NAME_TO_RUNTIME_PROPERTY.put(def.getName(), prop); + if (def.hasCcAlias()) { + this.PROPERTY_NAME_TO_RUNTIME_PROPERTY.put(def.getCcAlias(), prop); + } + } + } + + @Override + public void removeProperty(String name) { + PropertyKey key = PropertyKey.fromValue(name); + if (key != null) { + this.PROPERTY_KEY_TO_RUNTIME_PROPERTY.remove(key); + } else { + RuntimeProperty prop = this.PROPERTY_NAME_TO_RUNTIME_PROPERTY.remove(name); + if (prop != null) { + if (!name.equals(prop.getPropertyDefinition().getName())) { + this.PROPERTY_NAME_TO_RUNTIME_PROPERTY.remove(prop.getPropertyDefinition().getName()); + } else if (prop.getPropertyDefinition().hasCcAlias()) { + this.PROPERTY_NAME_TO_RUNTIME_PROPERTY.remove(prop.getPropertyDefinition().getCcAlias()); + } + } + } + } + + @Override + public void removeProperty(PropertyKey key) { + this.PROPERTY_KEY_TO_RUNTIME_PROPERTY.remove(key); + } + + @SuppressWarnings("unchecked") + @Override + public RuntimeProperty getProperty(String name) { + try { + PropertyKey key = PropertyKey.fromValue(name); + if (key != null) { + return getProperty(key); + } + // if there is no such PropertyKey then it could be a custom property + return (RuntimeProperty) this.PROPERTY_NAME_TO_RUNTIME_PROPERTY.get(name); + + } catch (ClassCastException ex) { + // TODO improve message + throw ExceptionFactory.createException(WrongArgumentException.class, ex.getMessage(), ex); + } + } + + @SuppressWarnings("unchecked") + @Override + public RuntimeProperty getProperty(PropertyKey key) { + try { + RuntimeProperty prop = (RuntimeProperty) this.PROPERTY_KEY_TO_RUNTIME_PROPERTY.get(key); + // for some of PropertyKey values we don't have property definitions, thus they are cached as custom properties + if (prop == null) { + prop = (RuntimeProperty) this.PROPERTY_NAME_TO_RUNTIME_PROPERTY.get(key.getKeyName()); + } + return prop; + + } catch (ClassCastException ex) { + // TODO improve message + throw ExceptionFactory.createException(WrongArgumentException.class, ex.getMessage(), ex); + } + } + + @Override + public RuntimeProperty getBooleanProperty(String name) { + return getProperty(name); + } + + @Override + public RuntimeProperty getBooleanProperty(PropertyKey key) { + return getProperty(key); + } + + @Override + public RuntimeProperty getIntegerProperty(String name) { + return getProperty(name); + } + + @Override + public RuntimeProperty getIntegerProperty(PropertyKey key) { + return getProperty(key); + } + + @Override + public RuntimeProperty getLongProperty(String name) { + return getProperty(name); + } + + @Override + public RuntimeProperty getLongProperty(PropertyKey key) { + return getProperty(key); + } + + @Override + public RuntimeProperty getMemorySizeProperty(String name) { + return getProperty(name); + } + + @Override + public RuntimeProperty getMemorySizeProperty(PropertyKey key) { + return getProperty(key); + } + + @Override + public RuntimeProperty getStringProperty(String name) { + return getProperty(name); + } + + @Override + public RuntimeProperty getStringProperty(PropertyKey key) { + return getProperty(key); + } + + @Override + public > RuntimeProperty getEnumProperty(String name) { + return getProperty(name); + } + + @Override + public > RuntimeProperty getEnumProperty(PropertyKey key) { + return getProperty(key); + } + + public void initializeProperties(Properties props) { + if (props != null) { + Properties infoCopy = (Properties) props.clone(); + + // TODO do we need to remove next properties (as it was before)? + infoCopy.remove(PropertyKey.HOST.getKeyName()); + infoCopy.remove(PropertyKey.PORT.getKeyName()); + infoCopy.remove(PropertyKey.USER.getKeyName()); + infoCopy.remove(PropertyKey.PASSWORD.getKeyName()); + infoCopy.remove(PropertyKey.DBNAME.getKeyName()); + + for (PropertyKey propKey : PropertyDefinitions.PROPERTY_KEY_TO_PROPERTY_DEFINITION.keySet()) { + try { + RuntimeProperty propToSet = getProperty(propKey); + propToSet.initializeFrom(infoCopy, null); + + } catch (CJException e) { + throw ExceptionFactory.createException(WrongArgumentException.class, e.getMessage(), e); + } + } + + // Translate legacy SSL properties if sslMode isn't explicitly set. Default sslMode is PREFERRED. + RuntimeProperty sslMode = this. getEnumProperty(PropertyKey.sslMode); + if (!sslMode.isExplicitlySet()) { + RuntimeProperty useSSL = this.getBooleanProperty(PropertyKey.useSSL); + RuntimeProperty verifyServerCertificate = this.getBooleanProperty(PropertyKey.verifyServerCertificate); + RuntimeProperty requireSSL = this.getBooleanProperty(PropertyKey.requireSSL); + if (useSSL.isExplicitlySet() || verifyServerCertificate.isExplicitlySet() || requireSSL.isExplicitlySet()) { + if (!useSSL.getValue()) { + sslMode.setValue(SslMode.DISABLED); + } else if (verifyServerCertificate.getValue()) { + sslMode.setValue(SslMode.VERIFY_CA); + } else if (requireSSL.getValue()) { + sslMode.setValue(SslMode.REQUIRED); + } + } + } + + // add user-defined properties + for (Object key : infoCopy.keySet()) { + String val = infoCopy.getProperty((String) key); + PropertyDefinition def = new StringPropertyDefinition((String) key, null, val, PropertyDefinitions.RUNTIME_MODIFIABLE, + Messages.getString("ConnectionProperties.unknown"), "8.0.10", PropertyDefinitions.CATEGORY_USER_DEFINED, Integer.MIN_VALUE); + RuntimeProperty p = new StringProperty(def); + addProperty(p); + } + postInitialization(); + } + } + + @Override + public void postInitialization() { + // no-op + } + + @Override + public Properties exposeAsProperties() { + Properties props = new Properties(); + for (PropertyKey propKey : this.PROPERTY_KEY_TO_RUNTIME_PROPERTY.keySet()) { + if (!props.containsKey(propKey.getKeyName())) { + RuntimeProperty propToGet = getProperty(propKey); + String propValue = propToGet.getStringValue(); + if (propValue != null) { + props.setProperty(propToGet.getPropertyDefinition().getName(), propValue); + } + } + } + + for (String propName : this.PROPERTY_NAME_TO_RUNTIME_PROPERTY.keySet()) { + if (!props.containsKey(propName)) { + RuntimeProperty propToGet = getProperty(propName); + String propValue = propToGet.getStringValue(); + if (propValue != null) { + props.setProperty(propToGet.getPropertyDefinition().getName(), propValue); + } + } + } + return props; + } + + @Override + public void reset() { + this.PROPERTY_KEY_TO_RUNTIME_PROPERTY.values().forEach(p -> p.resetValue()); + this.PROPERTY_NAME_TO_RUNTIME_PROPERTY.values().forEach(p -> p.resetValue()); + postInitialization(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/EnumProperty.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/EnumProperty.java new file mode 100644 index 0000000..f95478f --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/EnumProperty.java @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2017, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +public class EnumProperty> extends AbstractRuntimeProperty { + + private static final long serialVersionUID = -60853080911910124L; + + protected EnumProperty(PropertyDefinition propertyDefinition) { + super(propertyDefinition); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/EnumPropertyDefinition.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/EnumPropertyDefinition.java new file mode 100644 index 0000000..17174bb --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/EnumPropertyDefinition.java @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2017, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +import java.util.Arrays; + +import com.mysql.cj.Messages; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.ExceptionInterceptor; +import com.mysql.cj.util.StringUtils; + +public class EnumPropertyDefinition> extends AbstractPropertyDefinition { + + private static final long serialVersionUID = -3297521968759540444L; + + private Class enumType; + + public EnumPropertyDefinition(PropertyKey key, T defaultValue, boolean isRuntimeModifiable, String description, String sinceVersion, String category, + int orderInCategory) { + super(key, defaultValue, isRuntimeModifiable, description, sinceVersion, category, orderInCategory); + if (defaultValue == null) { + throw ExceptionFactory.createException("Enum property '" + key.getKeyName() + "' cannot be initialized with null."); + } + this.enumType = defaultValue.getDeclaringClass(); + } + + @Override + public String[] getAllowableValues() { + return Arrays.stream(this.enumType.getEnumConstants()).map(T::toString).sorted().toArray(String[]::new); + } + + @Override + public T parseObject(String value, ExceptionInterceptor exceptionInterceptor) { + try { + return Enum.valueOf(this.enumType, value.toUpperCase()); + } catch (Exception e) { + throw ExceptionFactory.createException( + Messages.getString("PropertyDefinition.1", + new Object[] { getName(), StringUtils.stringArrayToString(getAllowableValues(), "'", "', '", "' or '", "'"), value }), + e, exceptionInterceptor); + } + } + + /** + * Creates an instance of EnumProperty. + * + * @return RuntimeProperty + */ + @Override + public RuntimeProperty createRuntimeProperty() { + return new EnumProperty<>(this); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/IntegerProperty.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/IntegerProperty.java new file mode 100644 index 0000000..fd16e6f --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/IntegerProperty.java @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.ExceptionInterceptor; +import com.mysql.cj.exceptions.WrongArgumentException; + +public class IntegerProperty extends AbstractRuntimeProperty { + + private static final long serialVersionUID = 9208223182595760858L; + + public IntegerProperty(PropertyDefinition propertyDefinition) { + super(propertyDefinition); + } + + @Override + protected void checkRange(Integer val, String valueAsString, ExceptionInterceptor exceptionInterceptor) { + if ((val.intValue() < getPropertyDefinition().getLowerBound()) || (val.intValue() > getPropertyDefinition().getUpperBound())) { + throw ExceptionFactory.createException(WrongArgumentException.class, + "The connection property '" + getPropertyDefinition().getName() + "' only accepts integer values in the range of " + + getPropertyDefinition().getLowerBound() + " - " + getPropertyDefinition().getUpperBound() + ", the value '" + + (valueAsString == null ? val.intValue() : valueAsString) + "' exceeds this range.", + exceptionInterceptor); + } + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/IntegerPropertyDefinition.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/IntegerPropertyDefinition.java new file mode 100644 index 0000000..f16fa52 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/IntegerPropertyDefinition.java @@ -0,0 +1,87 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.ExceptionInterceptor; +import com.mysql.cj.exceptions.WrongArgumentException; + +public class IntegerPropertyDefinition extends AbstractPropertyDefinition { + + private static final long serialVersionUID = 4151893695173946081L; + + protected int multiplier = 1; + + public IntegerPropertyDefinition(PropertyKey key, int defaultValue, boolean isRuntimeModifiable, String description, String sinceVersion, String category, + int orderInCategory) { + super(key, Integer.valueOf(defaultValue), isRuntimeModifiable, description, sinceVersion, category, orderInCategory); + } + + public IntegerPropertyDefinition(PropertyKey key, int defaultValue, boolean isRuntimeModifiable, String description, String sinceVersion, String category, + int orderInCategory, int lowerBound, int upperBound) { + super(key, Integer.valueOf(defaultValue), isRuntimeModifiable, description, sinceVersion, category, orderInCategory, lowerBound, upperBound); + } + + @Override + public boolean isRangeBased() { + return getUpperBound() != getLowerBound(); + } + + @Override + public Integer parseObject(String value, ExceptionInterceptor exceptionInterceptor) { + return integerFrom(getName(), value, this.multiplier, exceptionInterceptor); + } + + /** + * Creates instance of IntegerProperty. + * + * @return RuntimeProperty + */ + @Override + public RuntimeProperty createRuntimeProperty() { + return new IntegerProperty(this); + } + + public static Integer integerFrom(String name, String value, int multiplier, ExceptionInterceptor exceptionInterceptor) { + try { + // Parse decimals, too + int intValue = (int) (Double.valueOf(value).doubleValue() * multiplier); + + // TODO check bounds + + return intValue; + + } catch (NumberFormatException nfe) { + throw ExceptionFactory.createException(WrongArgumentException.class, + "The connection property '" + name + "' only accepts integer values. The value '" + value + "' can not be converted to an integer.", + exceptionInterceptor); + } + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/LongProperty.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/LongProperty.java new file mode 100644 index 0000000..989579c --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/LongProperty.java @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.ExceptionInterceptor; +import com.mysql.cj.exceptions.WrongArgumentException; + +public class LongProperty extends AbstractRuntimeProperty { + + private static final long serialVersionUID = 1814429804634837665L; + + protected LongProperty(PropertyDefinition propertyDefinition) { + super(propertyDefinition); + } + + @Override + protected void checkRange(Long val, String valueAsString, ExceptionInterceptor exceptionInterceptor) { + if ((val.longValue() < getPropertyDefinition().getLowerBound()) || (val.longValue() > getPropertyDefinition().getUpperBound())) { + throw ExceptionFactory.createException(WrongArgumentException.class, + "The connection property '" + getPropertyDefinition().getName() + "' only accepts long integer values in the range of " + + getPropertyDefinition().getLowerBound() + " - " + getPropertyDefinition().getUpperBound() + ", the value '" + + (valueAsString == null ? val.longValue() : valueAsString) + "' exceeds this range.", + exceptionInterceptor); + } + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/LongPropertyDefinition.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/LongPropertyDefinition.java new file mode 100644 index 0000000..52903df --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/LongPropertyDefinition.java @@ -0,0 +1,77 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.ExceptionInterceptor; +import com.mysql.cj.exceptions.WrongArgumentException; + +public class LongPropertyDefinition extends AbstractPropertyDefinition { + + private static final long serialVersionUID = -5264490959206230852L; + + public LongPropertyDefinition(PropertyKey key, long defaultValue, boolean isRuntimeModifiable, String description, String sinceVersion, String category, + int orderInCategory) { + super(key, Long.valueOf(defaultValue), isRuntimeModifiable, description, sinceVersion, category, orderInCategory); + } + + public LongPropertyDefinition(PropertyKey key, long defaultValue, boolean isRuntimeModifiable, String description, String sinceVersion, String category, + int orderInCategory, long lowerBound, long upperBound) { + super(key, Long.valueOf(defaultValue), isRuntimeModifiable, description, sinceVersion, category, orderInCategory, (int) lowerBound, (int) upperBound); + } + + @Override + public Long parseObject(String value, ExceptionInterceptor exceptionInterceptor) { + try { + // Parse decimals, too + return Double.valueOf(value).longValue(); + + } catch (NumberFormatException nfe) { + throw ExceptionFactory.createException(WrongArgumentException.class, "The connection property '" + getName() + + "' only accepts long integer values. The value '" + value + "' can not be converted to a long integer.", exceptionInterceptor); + } + } + + @Override + public boolean isRangeBased() { + return getUpperBound() != getLowerBound(); + } + + /** + * Creates instance of LongProperty. + * + * @return RuntimeProperty + */ + @Override + public RuntimeProperty createRuntimeProperty() { + return new LongProperty(this); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/MemorySizeProperty.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/MemorySizeProperty.java new file mode 100644 index 0000000..5ee4bc2 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/MemorySizeProperty.java @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +import java.util.Properties; + +import javax.naming.Reference; + +import com.mysql.cj.exceptions.ExceptionInterceptor; + +public class MemorySizeProperty extends IntegerProperty { + + private static final long serialVersionUID = 4200558564320133284L; + + private String initialValueAsString; + + protected String valueAsString; + + protected MemorySizeProperty(PropertyDefinition propertyDefinition) { + super(propertyDefinition); + this.valueAsString = propertyDefinition.getDefaultValue().toString(); + } + + @Override + public void initializeFrom(Properties extractFrom, ExceptionInterceptor exceptionInterceptor) { + super.initializeFrom(extractFrom, exceptionInterceptor); + this.initialValueAsString = this.valueAsString; + } + + @Override + public void initializeFrom(Reference ref, ExceptionInterceptor exceptionInterceptor) { + super.initializeFrom(ref, exceptionInterceptor); + this.initialValueAsString = this.valueAsString; + } + + @Override + public String getStringValue() { + return this.valueAsString; + } + + @Override + public void setValueInternal(Integer value, String valueAsString, ExceptionInterceptor exceptionInterceptor) { + super.setValueInternal(value, valueAsString, exceptionInterceptor); + this.valueAsString = valueAsString == null ? String.valueOf(value.intValue()) : valueAsString; + } + + @Override + public void resetValue() { + this.value = this.initialValue; + this.valueAsString = this.initialValueAsString; + invokeListeners(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/MemorySizePropertyDefinition.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/MemorySizePropertyDefinition.java new file mode 100644 index 0000000..7444a95 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/MemorySizePropertyDefinition.java @@ -0,0 +1,80 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +import com.mysql.cj.exceptions.ExceptionInterceptor; +import com.mysql.cj.util.StringUtils; + +public class MemorySizePropertyDefinition extends IntegerPropertyDefinition { + + private static final long serialVersionUID = -6878680905514177949L; + + public MemorySizePropertyDefinition(PropertyKey key, int defaultValue, boolean isRuntimeModifiable, String description, String sinceVersion, + String category, int orderInCategory) { + super(key, defaultValue, isRuntimeModifiable, description, sinceVersion, category, orderInCategory); + } + + public MemorySizePropertyDefinition(PropertyKey key, int defaultValue, boolean isRuntimeModifiable, String description, String sinceVersion, + String category, int orderInCategory, int lowerBound, int upperBound) { + super(key, defaultValue, isRuntimeModifiable, description, sinceVersion, category, orderInCategory, lowerBound, upperBound); + } + + @Override + public Integer parseObject(String value, ExceptionInterceptor exceptionInterceptor) { + this.multiplier = 1; + + if (value.endsWith("k") || value.endsWith("K") || value.endsWith("kb") || value.endsWith("Kb") || value.endsWith("kB") || value.endsWith("KB")) { + this.multiplier = 1024; + int indexOfK = StringUtils.indexOfIgnoreCase(value, "k"); + value = value.substring(0, indexOfK); + } else if (value.endsWith("m") || value.endsWith("M") || value.endsWith("mb") || value.endsWith("Mb") || value.endsWith("mB") || value.endsWith("MB")) { + this.multiplier = 1024 * 1024; + int indexOfM = StringUtils.indexOfIgnoreCase(value, "m"); + value = value.substring(0, indexOfM); + } else if (value.endsWith("g") || value.endsWith("G") || value.endsWith("gb") || value.endsWith("Gb") || value.endsWith("gB") || value.endsWith("GB")) { + this.multiplier = 1024 * 1024 * 1024; + int indexOfG = StringUtils.indexOfIgnoreCase(value, "g"); + value = value.substring(0, indexOfG); + } + + return super.parseObject(value, exceptionInterceptor); + } + + /** + * Creates instance of ReadableMemorySizeProperty or ModifiableMemorySizeProperty depending on isRuntimeModifiable() result. + * + * @return RuntimeProperty + */ + @Override + public RuntimeProperty createRuntimeProperty() { + return new MemorySizeProperty(this); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/StringProperty.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/StringProperty.java new file mode 100644 index 0000000..d9b2752 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/StringProperty.java @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +public class StringProperty extends AbstractRuntimeProperty { + + private static final long serialVersionUID = -4141084145739428803L; + + protected StringProperty(PropertyDefinition propertyDefinition) { + super(propertyDefinition); + } + + @Override + public String getStringValue() { + return this.value; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/StringPropertyDefinition.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/StringPropertyDefinition.java new file mode 100644 index 0000000..7b5445f --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/StringPropertyDefinition.java @@ -0,0 +1,62 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf; + +import com.mysql.cj.exceptions.ExceptionInterceptor; + +public class StringPropertyDefinition extends AbstractPropertyDefinition { + + private static final long serialVersionUID = 8228934389127796555L; + + public StringPropertyDefinition(String name, String alias, String defaultValue, boolean isRuntimeModifiable, String description, String sinceVersion, + String category, int orderInCategory) { + super(name, alias, defaultValue, isRuntimeModifiable, description, sinceVersion, category, orderInCategory); + } + + public StringPropertyDefinition(PropertyKey key, String defaultValue, boolean isRuntimeModifiable, String description, String sinceVersion, String category, + int orderInCategory) { + super(key, defaultValue, isRuntimeModifiable, description, sinceVersion, category, orderInCategory); + } + + @Override + public String parseObject(String value, ExceptionInterceptor exceptionInterceptor) { + return value; + } + + /** + * Creates instance of ReadableStringProperty or ModifiableStringProperty depending on isRuntimeModifiable() result. + * + * @return RuntimeProperty + */ + @Override + public RuntimeProperty createRuntimeProperty() { + return new StringProperty(this); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/FailoverConnectionUrl.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/FailoverConnectionUrl.java new file mode 100644 index 0000000..d297ae1 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/FailoverConnectionUrl.java @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2016, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf.url; + +import java.util.Properties; + +import com.mysql.cj.conf.ConnectionUrl; +import com.mysql.cj.conf.ConnectionUrlParser; + +public class FailoverConnectionUrl extends ConnectionUrl { + /** + * Constructs an instance of {@link FailoverConnectionUrl}, performing all the required initializations. + * + * @param connStrParser + * a {@link ConnectionUrlParser} instance containing the parsed version of the original connection string + * @param info + * the connection arguments map + */ + public FailoverConnectionUrl(ConnectionUrlParser connStrParser, Properties info) { + super(connStrParser, info); + this.type = Type.FAILOVER_CONNECTION; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/FailoverDnsSrvConnectionUrl.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/FailoverDnsSrvConnectionUrl.java new file mode 100644 index 0000000..d50d786 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/FailoverDnsSrvConnectionUrl.java @@ -0,0 +1,115 @@ +/* + * Copyright (c) 2019, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf.url; + +import java.util.List; +import java.util.Map; +import java.util.Properties; + +import com.mysql.cj.Messages; +import com.mysql.cj.conf.BooleanPropertyDefinition; +import com.mysql.cj.conf.ConnectionUrl; +import com.mysql.cj.conf.ConnectionUrlParser; +import com.mysql.cj.conf.HostInfo; +import com.mysql.cj.conf.HostsListView; +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.InvalidConnectionAttributeException; + +public class FailoverDnsSrvConnectionUrl extends ConnectionUrl { + private static final String DEFAULT_HOST = ""; + private static final int DEFAULT_PORT = HostInfo.NO_PORT; + + /** + * Constructs an instance of {@link FailoverDnsSrvConnectionUrl}, performing all the required initializations. + * + * @param connStrParser + * a {@link ConnectionUrlParser} instance containing the parsed version of the original connection string + * @param info + * the connection arguments map + */ + public FailoverDnsSrvConnectionUrl(ConnectionUrlParser connStrParser, Properties info) { + super(connStrParser, info); + this.type = Type.FAILOVER_DNS_SRV_CONNECTION; + + /* + * Validate the hosts list: + * 1. One host (SRV service name) must be provided. + * 2. No more than one host (SRV service name) can be provided. + * 3. No port can be provided, i.e., port number must be equals to DEFAULT_PORT. + * 4. If property 'dnsSrv' is set then it cannot be "false". + * 5. Property 'protocol' cannot be "PIPE". + */ + HostInfo srvHost = super.getMainHost(); + Map hostProps = srvHost.getHostProperties(); + if (DEFAULT_HOST.equals(srvHost.getHost())) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, Messages.getString("ConnectionString.18")); + } + if (this.hosts.size() != 1) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, Messages.getString("ConnectionString.19")); + } + if (srvHost.getPort() != DEFAULT_PORT) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, Messages.getString("ConnectionString.22")); + } + if (hostProps.containsKey(PropertyKey.dnsSrv.getKeyName())) { + if (!BooleanPropertyDefinition.booleanFrom(PropertyKey.dnsSrv.getKeyName(), hostProps.get(PropertyKey.dnsSrv.getKeyName()), null)) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, + Messages.getString("ConnectionString.23", new Object[] { PropertyKey.dnsSrv.getKeyName() })); + } + } + if (hostProps.containsKey(PropertyKey.PROTOCOL.getKeyName()) && hostProps.get(PropertyKey.PROTOCOL.getKeyName()).equalsIgnoreCase("PIPE")) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, Messages.getString("ConnectionString.24")); + } + } + + @Override + public String getDefaultHost() { + return DEFAULT_HOST; + } + + @Override + public int getDefaultPort() { + return DEFAULT_PORT; + } + + /** + * Returns a hosts list built from the result of the DNS SRV lookup for the original host name. + * + * @param view + * the type of the view to use in the returned list of hosts. This argument is ignored in this implementation. + * + * @return + * the hosts list from the result of the DNS SRV lookup, filtered for the given view. + */ + @Override + public List getHostsList(HostsListView view) { + return getHostsListFromDnsSrv(getMainHost()); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/LoadBalanceConnectionUrl.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/LoadBalanceConnectionUrl.java new file mode 100644 index 0000000..d71aea6 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/LoadBalanceConnectionUrl.java @@ -0,0 +1,137 @@ +/* + * Copyright (c) 2016, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf.url; + +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.Properties; +import java.util.stream.Collectors; + +import com.mysql.cj.conf.ConnectionUrl; +import com.mysql.cj.conf.ConnectionUrlParser; +import com.mysql.cj.conf.HostInfo; +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.util.StringUtils; + +public class LoadBalanceConnectionUrl extends ConnectionUrl { + /** + * Constructs an instance of {@link LoadBalanceConnectionUrl}, performing all the required initializations and validations. A load-balanced connection + * cannot deal with multiple hosts with same host:port. + * + * @param connStrParser + * a {@link ConnectionUrlParser} instance containing the parsed version of the original connection string + * @param info + * the connection arguments map + */ + public LoadBalanceConnectionUrl(ConnectionUrlParser connStrParser, Properties info) { + super(connStrParser, info); + this.type = Type.LOADBALANCE_CONNECTION; + + // TODO: Validate the hosts list: there can't be any two hosts with same host:port. + // Although this should be required, it also is incompatible with our current tests which are creating load-balanced connections + // using the same host configurations. + // Set visitedHosts = new HashSet<>(); + // for (HostInfo hi : this.hosts) { + // if (visitedHosts.contains(hi.getHostPortPair())) { + // throw ExceptionFactory.createException(WrongArgumentException.class, + // Messages.getString("ConnectionString.12", new Object[] { hi.getHostPortPair(), Type.LOADBALANCE_CONNECTION.getProtocol() })); + // } + // visitedHosts.add(hi.getHostPortPair()); + // } + } + + /** + * Constructs an instance of a {@link LoadBalanceConnectionUrl} based on a list of hosts and a global set of properties instead of connection string + * parsing. + * {@link ConnectionUrl} instances created by this process are not cached. + * + * @param hosts + * the hosts list to use in this connection URL + * @param properties + * the properties common to all hosts + */ + public LoadBalanceConnectionUrl(List hosts, Map properties) { + this.originalConnStr = ConnectionUrl.Type.LOADBALANCE_CONNECTION.getScheme() + "//**internally_generated**" + System.currentTimeMillis() + "**"; + this.originalDatabase = properties.containsKey(PropertyKey.DBNAME.getKeyName()) ? properties.get(PropertyKey.DBNAME.getKeyName()) : ""; + this.type = ConnectionUrl.Type.LOADBALANCE_CONNECTION; + this.properties.putAll(properties); + injectPerTypeProperties(this.properties); + setupPropertiesTransformer(); // This is needed if new hosts come to be spawned in this connection URL. + hosts.stream().map(this::fixHostInfo).forEach(this.hosts::add); // Fix the hosts info based on the new properties before adding them. + } + + /** + * Injects additional properties into the connection arguments while it's being constructed. + * + * @param props + * the properties already containing all known connection arguments + */ + @Override + protected void injectPerTypeProperties(Map props) { + if (props.containsKey(PropertyKey.loadBalanceAutoCommitStatementThreshold.getKeyName())) { + try { + int autoCommitSwapThreshold = Integer.parseInt(props.get(PropertyKey.loadBalanceAutoCommitStatementThreshold.getKeyName())); + if (autoCommitSwapThreshold > 0) { + String queryInterceptors = props.get(PropertyKey.queryInterceptors.getKeyName()); + String lbi = "com.mysql.cj.jdbc.ha.LoadBalancedAutoCommitInterceptor"; + if (StringUtils.isNullOrEmpty(queryInterceptors)) { + props.put(PropertyKey.queryInterceptors.getKeyName(), lbi); + } else { + props.put(PropertyKey.queryInterceptors.getKeyName(), queryInterceptors + "," + lbi); + } + } + } catch (Throwable t) { + // Ignore, this will be handled later. + } + } + } + + /** + * Returns a list of this connection URL hosts in the form of host:port pairs. + * + * @return a list of this connection URL hosts in the form of host:port pairs + */ + public List getHostInfoListAsHostPortPairs() { + return this.hosts.stream().map(hi -> hi.getHostPortPair()).collect(Collectors.toList()); + } + + /** + * Returns the list of {@link HostInfo} instances that matches the given collection of host:port pairs. Isolated host info elements are spawned for the + * missing elements. + * + * @param hostPortPairs + * a list of host:port pairs + * @return a list of {@link HostInfo} instances corresponding to the given host:port pairs + */ + public List getHostInfoListFromHostPortPairs(Collection hostPortPairs) { + return hostPortPairs.stream().map(this::getHostOrSpawnIsolated).collect(Collectors.toList()); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/LoadBalanceDnsSrvConnectionUrl.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/LoadBalanceDnsSrvConnectionUrl.java new file mode 100644 index 0000000..48fcdff --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/LoadBalanceDnsSrvConnectionUrl.java @@ -0,0 +1,148 @@ +/* + * Copyright (c) 2019, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf.url; + +import java.util.List; +import java.util.Map; +import java.util.Properties; + +import com.mysql.cj.Messages; +import com.mysql.cj.conf.BooleanPropertyDefinition; +import com.mysql.cj.conf.ConnectionUrl; +import com.mysql.cj.conf.ConnectionUrlParser; +import com.mysql.cj.conf.HostInfo; +import com.mysql.cj.conf.HostsListView; +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.InvalidConnectionAttributeException; +import com.mysql.cj.util.StringUtils; + +public class LoadBalanceDnsSrvConnectionUrl extends ConnectionUrl { + private static final String DEFAULT_HOST = ""; + private static final int DEFAULT_PORT = HostInfo.NO_PORT; + + /** + * Constructs an instance of {@link LoadBalanceDnsSrvConnectionUrl}, performing all the required initializations and validations. + * + * @param connStrParser + * a {@link ConnectionUrlParser} instance containing the parsed version of the original connection string + * @param info + * the connection arguments map + */ + public LoadBalanceDnsSrvConnectionUrl(ConnectionUrlParser connStrParser, Properties info) { + super(connStrParser, info); + this.type = Type.LOADBALANCE_DNS_SRV_CONNECTION; + + /* + * Validate the hosts list: + * 1. One host (SRV service name) must be provided. + * 2. No more than one host (SRV service name) can be provided. + * 3. No port can be provided, i.e., port number must be equals to DEFAULT_PORT. + * 4. If property 'dnsSrv' is set then it cannot be "false". + * 5. Property 'protocol' cannot be "PIPE". + * 6. Property 'loadBalanceConnectionGroup' cannot be set. + */ + HostInfo srvHost = super.getMainHost(); + Map hostProps = srvHost.getHostProperties(); + if (DEFAULT_HOST.equals(srvHost.getHost())) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, Messages.getString("ConnectionString.18")); + } + if (this.hosts.size() != 1) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, Messages.getString("ConnectionString.19")); + } + if (srvHost.getPort() != DEFAULT_PORT) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, Messages.getString("ConnectionString.22")); + } + if (hostProps.containsKey(PropertyKey.dnsSrv.getKeyName())) { + if (!BooleanPropertyDefinition.booleanFrom(PropertyKey.dnsSrv.getKeyName(), hostProps.get(PropertyKey.dnsSrv.getKeyName()), null)) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, + Messages.getString("ConnectionString.23", new Object[] { PropertyKey.dnsSrv.getKeyName() })); + } + } + if (hostProps.containsKey(PropertyKey.PROTOCOL.getKeyName()) && hostProps.get(PropertyKey.PROTOCOL.getKeyName()).equalsIgnoreCase("PIPE")) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, Messages.getString("ConnectionString.24")); + } + if (hostProps.containsKey(PropertyKey.loadBalanceConnectionGroup.getKeyName())) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, + Messages.getString("ConnectionString.25", new Object[] { PropertyKey.loadBalanceConnectionGroup.getKeyName() })); + } + } + + /** + * Injects additional properties into the connection arguments while the connection arguments map + * is being constructed. + * + * @param props + * the properties already containing all known connection arguments + */ + @Override + protected void injectPerTypeProperties(Map props) { + if (props.containsKey(PropertyKey.loadBalanceAutoCommitStatementThreshold.getKeyName())) { + try { + int autoCommitSwapThreshold = Integer.parseInt(props.get(PropertyKey.loadBalanceAutoCommitStatementThreshold.getKeyName())); + if (autoCommitSwapThreshold > 0) { + String queryInterceptors = props.get(PropertyKey.queryInterceptors.getKeyName()); + String lbi = "com.mysql.cj.jdbc.ha.LoadBalancedAutoCommitInterceptor"; + if (StringUtils.isNullOrEmpty(queryInterceptors)) { + props.put(PropertyKey.queryInterceptors.getKeyName(), lbi); + } else { + props.put(PropertyKey.queryInterceptors.getKeyName(), queryInterceptors + "," + lbi); + } + } + } catch (Throwable t) { + // Ignore, this will be handled later. + } + } + } + + @Override + public String getDefaultHost() { + return DEFAULT_HOST; + } + + @Override + public int getDefaultPort() { + return DEFAULT_PORT; + } + + /** + * Returns a hosts list built from the result of the DNS SRV lookup for the original host name. + * + * @param view + * the type of the view to use in the returned list of hosts. This argument is ignored in this implementation. + * + * @return + * the hosts list from the result of the DNS SRV lookup, filtered for the given view. + */ + @Override + public List getHostsList(HostsListView view) { + return getHostsListFromDnsSrv(getMainHost()); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/ReplicationConnectionUrl.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/ReplicationConnectionUrl.java new file mode 100644 index 0000000..40ee9f2 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/ReplicationConnectionUrl.java @@ -0,0 +1,216 @@ +/* + * Copyright (c) 2016, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf.url; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Properties; +import java.util.stream.Collectors; + +import com.mysql.cj.conf.ConnectionUrl; +import com.mysql.cj.conf.ConnectionUrlParser; +import com.mysql.cj.conf.HostInfo; +import com.mysql.cj.conf.HostsListView; +import com.mysql.cj.conf.PropertyKey; + +public class ReplicationConnectionUrl extends ConnectionUrl { + private static final String TYPE_SOURCE = "SOURCE"; + private static final String TYPE_REPLICA = "REPLICA"; + @Deprecated + private static final String TYPE_SOURCE_DEPRECATED = "MASTER"; + @Deprecated + private static final String TYPE_REPLICA_DEPRECATED = "SLAVE"; + + private List sourceHosts = new ArrayList<>(); + private List replicaHosts = new ArrayList<>(); + + /** + * Constructs an instance of {@link ReplicationConnectionUrl}, performing all the required initializations. + * + * @param connStrParser + * a {@link ConnectionUrlParser} instance containing the parsed version of the original connection string + * @param info + * the connection arguments map + */ + public ReplicationConnectionUrl(ConnectionUrlParser connStrParser, Properties info) { + super(connStrParser, info); + this.type = Type.REPLICATION_CONNECTION; + + // Split sources and replicas: + LinkedList undefinedHosts = new LinkedList<>(); + for (HostInfo hi : this.hosts) { + Map hostProperties = hi.getHostProperties(); + if (hostProperties.containsKey(PropertyKey.TYPE.getKeyName())) { + if (TYPE_SOURCE.equalsIgnoreCase(hostProperties.get(PropertyKey.TYPE.getKeyName())) + || TYPE_SOURCE_DEPRECATED.equalsIgnoreCase(hostProperties.get(PropertyKey.TYPE.getKeyName()))) { + this.sourceHosts.add(hi); + } else if (TYPE_REPLICA.equalsIgnoreCase(hostProperties.get(PropertyKey.TYPE.getKeyName())) + || TYPE_REPLICA_DEPRECATED.equalsIgnoreCase(hostProperties.get(PropertyKey.TYPE.getKeyName()))) { + this.replicaHosts.add(hi); + } else { + undefinedHosts.add(hi); + } + } else { + undefinedHosts.add(hi); + } + } + if (!undefinedHosts.isEmpty()) { + if (this.sourceHosts.isEmpty()) { + this.sourceHosts.add(undefinedHosts.removeFirst()); + } + this.replicaHosts.addAll(undefinedHosts); + } + + // TODO: Validate the hosts list: there can't be any two hosts with same host:port. + // Although this should be required, it also is incompatible with our current tests which are creating replication connections + // using the same host configurations. + // Set visitedHosts = new HashSet<>(); + // for (List hostsLists : Arrays.asList(this.sourceHosts, this.replicaHosts)) { + // for (HostInfo hi : hostsLists) { + // if (visitedHosts.contains(hi.getHostPortPair())) { + // throw ExceptionFactory.createException(WrongArgumentException.class, + // Messages.getString("ConnectionString.13", new Object[] { hi.getHostPortPair(), Type.REPLICATION_CONNECTION.getProtocol() })); + // } + // visitedHosts.add(hi.getHostPortPair()); + // } + // } + } + + /** + * Constructs an instance of a {@link ReplicationConnectionUrl} based on a list of source hosts, a list of replica hosts and a global set of properties + * instead of connection string parsing. + * {@link ConnectionUrl} instances created by this process are not cached. + * + * @param sources + * the source hosts list to use in this connection string + * @param replicas + * the replica hosts list to use in this connection string + * @param properties + * the properties common to all hosts + */ + public ReplicationConnectionUrl(List sources, List replicas, Map properties) { + this.originalConnStr = ConnectionUrl.Type.REPLICATION_CONNECTION.getScheme() + "//**internally_generated**" + System.currentTimeMillis() + "**"; + this.originalDatabase = properties.containsKey(PropertyKey.DBNAME.getKeyName()) ? properties.get(PropertyKey.DBNAME.getKeyName()) : ""; + this.type = ConnectionUrl.Type.REPLICATION_CONNECTION; + this.properties.putAll(properties); + injectPerTypeProperties(this.properties); + setupPropertiesTransformer(); // This is needed if new hosts come to be spawned in this connection URL. + sources.stream().map(this::fixHostInfo).peek(this.sourceHosts::add).forEach(this.hosts::add); // Fix the hosts info based on the new properties before adding them. + replicas.stream().map(this::fixHostInfo).peek(this.replicaHosts::add).forEach(this.hosts::add); // Fix the hosts info based on the new properties before adding them. + } + + /** + * Returns a list of the hosts in this connection URL, filtered for the given view. + * + * @param view + * the type of the view to use in the returned list of hosts. + * @return + * the hosts list from this connection URL, filtered for the given view. + */ + @Override + public List getHostsList(HostsListView view) { + switch (view) { + case SOURCES: + return Collections.unmodifiableList(this.sourceHosts); + case REPLICAS: + return Collections.unmodifiableList(this.replicaHosts); + default: + return super.getHostsList(HostsListView.ALL); + } + } + + /** + * Returns an existing source host info with the same host:port part or spawns a new isolated host info based on this connection URL if none was found. + * + * @param hostPortPair + * the host:port part to search for + * @return the existing host info or a new independent one + */ + public HostInfo getSourceHostOrSpawnIsolated(String hostPortPair) { + return super.getHostOrSpawnIsolated(hostPortPair, this.sourceHosts); + } + + /** + * Returns a list of this connection URL source hosts in the form of host:port pairs. + * + * @return a list of this connection URL source hosts in the form of host:port pairs + */ + public List getSourcesListAsHostPortPairs() { + return this.sourceHosts.stream().map(hi -> hi.getHostPortPair()).collect(Collectors.toList()); + } + + /** + * Returns the list of {@link HostInfo} instances that matches the given collection of host:port pairs in the corresponding hosts list. Isolated host info + * elements are spawned for the missing elements. + * + * @param hostPortPairs + * a list of host:port pairs + * @return a list of {@link HostInfo} instances corresponding to the given host:port pairs + */ + public List getSourceHostsListFromHostPortPairs(Collection hostPortPairs) { + return hostPortPairs.stream().map(this::getSourceHostOrSpawnIsolated).collect(Collectors.toList()); + } + + /** + * Returns an existing replica host info with the same host:port part or spawns a new isolated host info based on this connection URL if none was found. + * + * @param hostPortPair + * the host:port part to search for + * @return the existing host info or a new independent one + */ + public HostInfo getReplicaHostOrSpawnIsolated(String hostPortPair) { + return super.getHostOrSpawnIsolated(hostPortPair, this.replicaHosts); + } + + /** + * Returns a list of this connection URL replica hosts in the form of host:port pairs. + * + * @return a list of this connection URL replica hosts in the form of host:port pairs + */ + public List getReplicasListAsHostPortPairs() { + return this.replicaHosts.stream().map(hi -> hi.getHostPortPair()).collect(Collectors.toList()); + } + + /** + * Returns the list of {@link HostInfo} instances that matches the given collection of host:port pairs in the corresponding hosts list. Isolated host info + * elements are spawned for the missing elements. + * + * @param hostPortPairs + * a list of host:port pairs + * @return a list of {@link HostInfo} instances corresponding to the given host:port pairs + */ + public List getReplicaHostsListFromHostPortPairs(Collection hostPortPairs) { + return hostPortPairs.stream().map(this::getReplicaHostOrSpawnIsolated).collect(Collectors.toList()); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/ReplicationDnsSrvConnectionUrl.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/ReplicationDnsSrvConnectionUrl.java new file mode 100644 index 0000000..892db5c --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/ReplicationDnsSrvConnectionUrl.java @@ -0,0 +1,170 @@ +/* + * Copyright (c) 2019, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf.url; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Properties; + +import com.mysql.cj.Messages; +import com.mysql.cj.conf.BooleanPropertyDefinition; +import com.mysql.cj.conf.ConnectionUrl; +import com.mysql.cj.conf.ConnectionUrlParser; +import com.mysql.cj.conf.HostInfo; +import com.mysql.cj.conf.HostsListView; +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.InvalidConnectionAttributeException; + +public class ReplicationDnsSrvConnectionUrl extends ConnectionUrl { + private static final String DEFAULT_HOST = ""; + private static final int DEFAULT_PORT = HostInfo.NO_PORT; + private static final String TYPE_SOURCE = "SOURCE"; + private static final String TYPE_REPLICA = "REPLICA"; + @Deprecated + private static final String TYPE_SOURCE_DEPRECATED = "MASTER"; + @Deprecated + private static final String TYPE_REPLICA_DEPRECATED = "SLAVE"; + + private List sourceHosts = new ArrayList<>(); + private List replicaHosts = new ArrayList<>(); + + /** + * Constructs an instance of {@link ReplicationDnsSrvConnectionUrl}, performing all the required initializations. + * + * @param connStrParser + * a {@link ConnectionUrlParser} instance containing the parsed version of the original connection string + * @param info + * the connection arguments map + */ + public ReplicationDnsSrvConnectionUrl(ConnectionUrlParser connStrParser, Properties info) { + super(connStrParser, info); + this.type = Type.REPLICATION_DNS_SRV_CONNECTION; + + // Split sources and replicas: + LinkedList undefinedHosts = new LinkedList<>(); + for (HostInfo hi : this.hosts) { + Map hostProperties = hi.getHostProperties(); + if (hostProperties.containsKey(PropertyKey.TYPE.getKeyName())) { + if (TYPE_SOURCE.equalsIgnoreCase(hostProperties.get(PropertyKey.TYPE.getKeyName())) + || TYPE_SOURCE_DEPRECATED.equalsIgnoreCase(hostProperties.get(PropertyKey.TYPE.getKeyName()))) { + this.sourceHosts.add(hi); + } else if (TYPE_REPLICA.equalsIgnoreCase(hostProperties.get(PropertyKey.TYPE.getKeyName())) + || TYPE_REPLICA_DEPRECATED.equalsIgnoreCase(hostProperties.get(PropertyKey.TYPE.getKeyName()))) { + this.replicaHosts.add(hi); + } else { + undefinedHosts.add(hi); + } + } else { + undefinedHosts.add(hi); + } + } + if (!undefinedHosts.isEmpty()) { + if (this.sourceHosts.isEmpty()) { + this.sourceHosts.add(undefinedHosts.removeFirst()); + } + this.replicaHosts.addAll(undefinedHosts); + } + + /* + * Validate the hosts list: + * 1. Exactly two hosts (SRV service name) must be provided. + * 2. No more than one host (SRV service name) per type can be provided. + * 3. No port can be provided, i.e., port number must be equals to DEFAULT_PORT. + * 4. If property 'dnsSrv' is set then it cannot be "false". + * 5. Property 'protocol' cannot be "PIPE". + * 6. Property 'replicationConnectionGroup' cannot be set. + */ + HostInfo srvHostSource = this.sourceHosts.isEmpty() ? null : this.sourceHosts.get(0); + Map hostPropsSource = srvHostSource == null ? Collections.emptyMap() : srvHostSource.getHostProperties(); + HostInfo srvHostReplica = this.replicaHosts.isEmpty() ? null : this.replicaHosts.get(0); + Map hostPropsReplica = srvHostReplica == null ? Collections.emptyMap() : srvHostReplica.getHostProperties(); + if (srvHostSource == null || srvHostReplica == null || DEFAULT_HOST.equals(srvHostSource.getHost()) || DEFAULT_HOST.equals(srvHostReplica.getHost())) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, Messages.getString("ConnectionString.20")); + } + if (this.sourceHosts.size() != 1 || this.replicaHosts.size() != 1) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, Messages.getString("ConnectionString.21")); + } + if (srvHostSource.getPort() != DEFAULT_PORT || srvHostReplica.getPort() != DEFAULT_PORT) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, Messages.getString("ConnectionString.22")); + } + if (hostPropsSource.containsKey(PropertyKey.dnsSrv.getKeyName()) || hostPropsReplica.containsKey(PropertyKey.dnsSrv.getKeyName())) { + if (!BooleanPropertyDefinition.booleanFrom(PropertyKey.dnsSrv.getKeyName(), hostPropsSource.get(PropertyKey.dnsSrv.getKeyName()), null) + || !BooleanPropertyDefinition.booleanFrom(PropertyKey.dnsSrv.getKeyName(), hostPropsReplica.get(PropertyKey.dnsSrv.getKeyName()), null)) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, + Messages.getString("ConnectionString.23", new Object[] { PropertyKey.dnsSrv.getKeyName() })); + } + } + if (hostPropsSource.containsKey(PropertyKey.PROTOCOL.getKeyName()) && hostPropsSource.get(PropertyKey.PROTOCOL.getKeyName()).equalsIgnoreCase("PIPE") + || hostPropsReplica.containsKey(PropertyKey.PROTOCOL.getKeyName()) + && hostPropsReplica.get(PropertyKey.PROTOCOL.getKeyName()).equalsIgnoreCase("PIPE")) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, Messages.getString("ConnectionString.24")); + } + if (hostPropsSource.containsKey(PropertyKey.replicationConnectionGroup.getKeyName()) + || hostPropsReplica.containsKey(PropertyKey.replicationConnectionGroup.getKeyName())) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, + Messages.getString("ConnectionString.25", new Object[] { PropertyKey.replicationConnectionGroup.getKeyName() })); + } + } + + @Override + public String getDefaultHost() { + return DEFAULT_HOST; + } + + @Override + public int getDefaultPort() { + return DEFAULT_PORT; + } + + /** + * Returns a hosts list built from the result of the DNS SRV lookup for the original host name. + * + * @param view + * the type of the view to use in the returned list of hosts. + * + * @return + * the hosts list from the result of the DNS SRV lookup, filtered for the given view. + */ + @Override + public List getHostsList(HostsListView view) { + switch (view) { + case SOURCES: + return getHostsListFromDnsSrv(this.sourceHosts.get(0)); + case REPLICAS: + return getHostsListFromDnsSrv(this.replicaHosts.get(0)); + default: + return super.getHostsList(HostsListView.ALL); + } + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/SingleConnectionUrl.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/SingleConnectionUrl.java new file mode 100644 index 0000000..9baaec7 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/SingleConnectionUrl.java @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2016, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf.url; + +import java.util.Properties; + +import com.mysql.cj.conf.ConnectionUrl; +import com.mysql.cj.conf.ConnectionUrlParser; + +public class SingleConnectionUrl extends ConnectionUrl { + /** + * Constructs an instance of {@link SingleConnectionUrl}, performing all the required initializations. + * + * @param connStrParser + * a {@link ConnectionUrlParser} instance containing the parsed version of the original connection string + * @param info + * the connection arguments map + */ + public SingleConnectionUrl(ConnectionUrlParser connStrParser, Properties info) { + super(connStrParser, info); + this.type = Type.SINGLE_CONNECTION; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/XDevApiConnectionUrl.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/XDevApiConnectionUrl.java new file mode 100644 index 0000000..c022da7 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/XDevApiConnectionUrl.java @@ -0,0 +1,169 @@ +/* + * Copyright (c) 2016, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf.url; + +import static com.mysql.cj.util.StringUtils.isNullOrEmpty; +import static com.mysql.cj.util.StringUtils.safeTrim; + +import java.util.Collections; +import java.util.Comparator; +import java.util.HashSet; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Properties; +import java.util.Set; +import java.util.stream.Collectors; + +import com.mysql.cj.Messages; +import com.mysql.cj.conf.ConnectionUrl; +import com.mysql.cj.conf.ConnectionUrlParser; +import com.mysql.cj.conf.ConnectionUrlParser.Pair; +import com.mysql.cj.conf.HostInfo; +import com.mysql.cj.conf.HostsListView; +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.WrongArgumentException; +import com.mysql.cj.util.StringUtils; + +public class XDevApiConnectionUrl extends ConnectionUrl { + private static final int DEFAULT_PORT = 33060; + + private boolean prioritySorted = false; + private boolean hasDuplicatedPriorities = false; + + /** + * Constructs an instance of {@link XDevApiConnectionUrl}, performing all the required initializations. + * + * @param connStrParser + * a {@link ConnectionUrlParser} instance containing the parsed version of the original connection string + * @param info + * the connection arguments map + */ + public XDevApiConnectionUrl(ConnectionUrlParser connStrParser, Properties info) { + super(connStrParser, info); + this.type = Type.XDEVAPI_SESSION; + + /* + * Validate the hosts list: + * 1. Same user and password are required in all hosts. + * 2. If the host property 'priority' is set for one host, then in needs to be set on all others too. + * 3. 'Priority' value must be between 0 and 100. + */ + boolean first = true; + String user = null; + String password = null; + boolean hasPriority = false; + Set priorities = new HashSet<>(); + for (HostInfo hi : this.hosts) { + if (first) { + first = false; + user = hi.getUser(); + password = hi.getPassword(); + hasPriority = hi.getHostProperties().containsKey(PropertyKey.PRIORITY.getKeyName()); + } else { + if (!StringUtils.nullSafeEqual(user, hi.getUser()) || !StringUtils.nullSafeEqual(password, hi.getPassword())) { + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("ConnectionString.14", new Object[] { Type.XDEVAPI_SESSION.getScheme() })); + } + if (hasPriority ^ hi.getHostProperties().containsKey(PropertyKey.PRIORITY.getKeyName())) { + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("ConnectionString.15", new Object[] { Type.XDEVAPI_SESSION.getScheme() })); + } + } + if (hasPriority) { + try { + int priority = Integer.parseInt(hi.getProperty(PropertyKey.PRIORITY.getKeyName())); + if (priority < 0 || priority > 100) { + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("ConnectionString.16", new Object[] { Type.XDEVAPI_SESSION.getScheme() })); + } + if (priorities.contains(priority)) { + this.hasDuplicatedPriorities = true; + } else { + priorities.add(priority); + } + } catch (NumberFormatException e) { + throw ExceptionFactory.createException(WrongArgumentException.class, + Messages.getString("ConnectionString.16", new Object[] { Type.XDEVAPI_SESSION.getScheme() })); + } + } + } + + // Sort the hosts list according to their priority settings. + if (hasPriority) { + this.prioritySorted = true; + this.hosts.sort( + Comparator.comparing(hi -> Integer.parseInt(hi.getHostProperties().get(PropertyKey.PRIORITY.getKeyName()))).reversed()); + } + } + + @Override + protected void preprocessPerTypeHostProperties(Map hostProps) { + if (hostProps.containsKey(PropertyKey.ADDRESS.getKeyName())) { + String address = hostProps.get(PropertyKey.ADDRESS.getKeyName()); + Pair hostPortPair = ConnectionUrlParser.parseHostPortPair(address); + String host = safeTrim(hostPortPair.left); + Integer port = hostPortPair.right; + if (!isNullOrEmpty(host) && !hostProps.containsKey(PropertyKey.HOST.getKeyName())) { + hostProps.put(PropertyKey.HOST.getKeyName(), host); + } + if (port != -1 && !hostProps.containsKey(PropertyKey.PORT.getKeyName())) { + hostProps.put(PropertyKey.PORT.getKeyName(), port.toString()); + } + } + } + + @Override + public int getDefaultPort() { + return DEFAULT_PORT; + } + + @Override + protected void fixProtocolDependencies(Map hostProps) { + // Not needed. Abort this operation. + } + + @Override + public List getHostsList(HostsListView view) { + if (this.prioritySorted) { + if (this.hasDuplicatedPriorities) { // Randomly sort hosts with same priority. + Map> hostsByPriority = this.hosts.stream() + .collect(Collectors.groupingBy(hi -> Integer.valueOf(hi.getHostProperties().get(PropertyKey.PRIORITY.getKeyName())))); + this.hosts = hostsByPriority.entrySet().stream() + .sorted(Comparator.>, Integer>comparing(Entry::getKey).reversed()).map(Entry::getValue) + .peek(Collections::shuffle).flatMap(List::stream).collect(Collectors.toList()); + } + } else { // Random sorted. + Collections.shuffle(this.hosts); + } + return super.getHostsList(view); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/XDevApiDnsSrvConnectionUrl.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/XDevApiDnsSrvConnectionUrl.java new file mode 100644 index 0000000..2a416e7 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/conf/url/XDevApiDnsSrvConnectionUrl.java @@ -0,0 +1,136 @@ +/* + * Copyright (c) 2019, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.conf.url; + +import static com.mysql.cj.util.StringUtils.isNullOrEmpty; +import static com.mysql.cj.util.StringUtils.safeTrim; + +import java.util.List; +import java.util.Map; +import java.util.Properties; + +import com.mysql.cj.Messages; +import com.mysql.cj.conf.BooleanPropertyDefinition; +import com.mysql.cj.conf.ConnectionUrl; +import com.mysql.cj.conf.ConnectionUrlParser; +import com.mysql.cj.conf.ConnectionUrlParser.Pair; +import com.mysql.cj.conf.HostInfo; +import com.mysql.cj.conf.HostsListView; +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.InvalidConnectionAttributeException; + +public class XDevApiDnsSrvConnectionUrl extends ConnectionUrl { + private static final String DEFAULT_HOST = ""; + private static final int DEFAULT_PORT = HostInfo.NO_PORT; + + /** + * Constructs an instance of {@link XDevApiDnsSrvConnectionUrl}, performing all the required initializations. + * + * @param connStrParser + * a {@link ConnectionUrlParser} instance containing the parsed version of the original connection string + * @param info + * the connection arguments map + */ + public XDevApiDnsSrvConnectionUrl(ConnectionUrlParser connStrParser, Properties info) { + super(connStrParser, info); + this.type = Type.XDEVAPI_DNS_SRV_SESSION; + + /* + * Validate the hosts list: + * 1. One host (SRV service name) must be provided. + * 2. No more than one host (SRV service name) can be provided. + * 3. No port can be provided, i.e., port number must be equals to DEFAULT_PORT. + * 4. If property 'xdevapi.dns-srv' is set then it cannot be "false". + */ + HostInfo srvHost = super.getMainHost(); + Map hostProps = srvHost.getHostProperties(); + if (DEFAULT_HOST.equals(srvHost.getHost())) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, Messages.getString("ConnectionString.18")); + } + if (this.hosts.size() != 1) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, Messages.getString("ConnectionString.19")); + } + if (srvHost.getPort() != DEFAULT_PORT) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, Messages.getString("ConnectionString.22")); + } + if (hostProps.containsKey(PropertyKey.xdevapiDnsSrv.getKeyName())) { + if (!BooleanPropertyDefinition.booleanFrom(PropertyKey.xdevapiDnsSrv.getKeyName(), hostProps.get(PropertyKey.xdevapiDnsSrv.getKeyName()), null)) { + throw ExceptionFactory.createException(InvalidConnectionAttributeException.class, + Messages.getString("ConnectionString.23", new Object[] { PropertyKey.xdevapiDnsSrv.getKeyName() })); + } + } + } + + @Override + protected void preprocessPerTypeHostProperties(Map hostProps) { + if (hostProps.containsKey(PropertyKey.ADDRESS.getKeyName())) { + String address = hostProps.get(PropertyKey.ADDRESS.getKeyName()); + Pair hostPortPair = ConnectionUrlParser.parseHostPortPair(address); + String host = safeTrim(hostPortPair.left); + Integer port = hostPortPair.right; + if (!isNullOrEmpty(host) && !hostProps.containsKey(PropertyKey.HOST.getKeyName())) { + hostProps.put(PropertyKey.HOST.getKeyName(), host); + } + if (port != -1 && !hostProps.containsKey(PropertyKey.PORT.getKeyName())) { + hostProps.put(PropertyKey.PORT.getKeyName(), port.toString()); + } + } + } + + @Override + public String getDefaultHost() { + return DEFAULT_HOST; + } + + @Override + public int getDefaultPort() { + return DEFAULT_PORT; + } + + @Override + protected void fixProtocolDependencies(Map hostProps) { + // Not needed. Abort this operation. + } + + /** + * Returns a hosts list built from the result of the DNS SRV lookup for the original host name. + * + * @param view + * the type of the view to use in the returned list of hosts. This argument is ignored in this implementation. + * + * @return + * the hosts list from the result of the DNS SRV lookup, filtered for the given view. + */ + @Override + public List getHostsList(HostsListView view) { + return getHostsListFromDnsSrv(getMainHost()); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/log/BaseMetricsHolder.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/log/BaseMetricsHolder.java new file mode 100644 index 0000000..c3f86e5 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/log/BaseMetricsHolder.java @@ -0,0 +1,375 @@ +/* + * Copyright (c) 2017, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.log; + +public class BaseMetricsHolder { + + private final static int HISTOGRAM_BUCKETS = 20; + + /** + * If gathering metrics, what was the execution time of the longest query so + * far ? + */ + private long longestQueryTimeMs = 0; + + private long maximumNumberTablesAccessed = 0; + + private long minimumNumberTablesAccessed = Long.MAX_VALUE; + + /** When was the last time we reported metrics? */ + //private long metricsLastReportedMs; + + private long numberOfPreparedExecutes = 0; + + private long numberOfPrepares = 0; + + private long numberOfQueriesIssued = 0; + + private long numberOfResultSetsCreated = 0; + + private long[] numTablesMetricsHistBreakpoints; + + private int[] numTablesMetricsHistCounts; + + private long[] oldHistBreakpoints = null; + + private int[] oldHistCounts = null; + + private long shortestQueryTimeMs = Long.MAX_VALUE; + + private double totalQueryTimeMs = 0; + + private long[] perfMetricsHistBreakpoints; + + private int[] perfMetricsHistCounts; + + private long queryTimeCount; + private double queryTimeSum; + private double queryTimeSumSquares; + private double queryTimeMean; + + private void createInitialHistogram(long[] breakpoints, long lowerBound, long upperBound) { + + double bucketSize = (((double) upperBound - (double) lowerBound) / HISTOGRAM_BUCKETS) * 1.25; + + if (bucketSize < 1) { + bucketSize = 1; + } + + for (int i = 0; i < HISTOGRAM_BUCKETS; i++) { + breakpoints[i] = lowerBound; + lowerBound += bucketSize; + } + } + + private void addToHistogram(int[] histogramCounts, long[] histogramBreakpoints, long value, int numberOfTimes, long currentLowerBound, + long currentUpperBound) { + if (histogramCounts == null) { + createInitialHistogram(histogramBreakpoints, currentLowerBound, currentUpperBound); + } else { + for (int i = 0; i < HISTOGRAM_BUCKETS; i++) { + if (histogramBreakpoints[i] >= value) { + histogramCounts[i] += numberOfTimes; + + break; + } + } + } + } + + private void addToPerformanceHistogram(long value, int numberOfTimes) { + checkAndCreatePerformanceHistogram(); + + addToHistogram(this.perfMetricsHistCounts, this.perfMetricsHistBreakpoints, value, numberOfTimes, + this.shortestQueryTimeMs == Long.MAX_VALUE ? 0 : this.shortestQueryTimeMs, this.longestQueryTimeMs); + } + + private void addToTablesAccessedHistogram(long value, int numberOfTimes) { + checkAndCreateTablesAccessedHistogram(); + + addToHistogram(this.numTablesMetricsHistCounts, this.numTablesMetricsHistBreakpoints, value, numberOfTimes, + this.minimumNumberTablesAccessed == Long.MAX_VALUE ? 0 : this.minimumNumberTablesAccessed, this.maximumNumberTablesAccessed); + } + + private void checkAndCreatePerformanceHistogram() { + if (this.perfMetricsHistCounts == null) { + this.perfMetricsHistCounts = new int[HISTOGRAM_BUCKETS]; + } + + if (this.perfMetricsHistBreakpoints == null) { + this.perfMetricsHistBreakpoints = new long[HISTOGRAM_BUCKETS]; + } + } + + private void checkAndCreateTablesAccessedHistogram() { + if (this.numTablesMetricsHistCounts == null) { + this.numTablesMetricsHistCounts = new int[HISTOGRAM_BUCKETS]; + } + + if (this.numTablesMetricsHistBreakpoints == null) { + this.numTablesMetricsHistBreakpoints = new long[HISTOGRAM_BUCKETS]; + } + } + + /** + * @param queryTimeMs + * query execution time in milliseconds + */ + public void registerQueryExecutionTime(long queryTimeMs) { + if (queryTimeMs > this.longestQueryTimeMs) { + this.longestQueryTimeMs = queryTimeMs; + + repartitionPerformanceHistogram(); + } + + addToPerformanceHistogram(queryTimeMs, 1); + + if (queryTimeMs < this.shortestQueryTimeMs) { + this.shortestQueryTimeMs = (queryTimeMs == 0) ? 1 : queryTimeMs; + } + + this.numberOfQueriesIssued++; + + this.totalQueryTimeMs += queryTimeMs; + } + + private void repartitionHistogram(int[] histCounts, long[] histBreakpoints, long currentLowerBound, long currentUpperBound) { + + if (this.oldHistCounts == null) { + this.oldHistCounts = new int[histCounts.length]; + this.oldHistBreakpoints = new long[histBreakpoints.length]; + } + + System.arraycopy(histCounts, 0, this.oldHistCounts, 0, histCounts.length); + + System.arraycopy(histBreakpoints, 0, this.oldHistBreakpoints, 0, histBreakpoints.length); + + createInitialHistogram(histBreakpoints, currentLowerBound, currentUpperBound); + + for (int i = 0; i < HISTOGRAM_BUCKETS; i++) { + addToHistogram(histCounts, histBreakpoints, this.oldHistBreakpoints[i], this.oldHistCounts[i], currentLowerBound, currentUpperBound); + } + } + + private void repartitionPerformanceHistogram() { + checkAndCreatePerformanceHistogram(); + + repartitionHistogram(this.perfMetricsHistCounts, this.perfMetricsHistBreakpoints, + this.shortestQueryTimeMs == Long.MAX_VALUE ? 0 : this.shortestQueryTimeMs, this.longestQueryTimeMs); + } + + private void repartitionTablesAccessedHistogram() { + checkAndCreateTablesAccessedHistogram(); + + repartitionHistogram(this.numTablesMetricsHistCounts, this.numTablesMetricsHistBreakpoints, + this.minimumNumberTablesAccessed == Long.MAX_VALUE ? 0 : this.minimumNumberTablesAccessed, this.maximumNumberTablesAccessed); + } + + public void reportMetrics(Log log) { + StringBuilder logMessage = new StringBuilder(256); + + logMessage.append("** Performance Metrics Report **\n"); + logMessage.append("\nLongest reported query: " + this.longestQueryTimeMs + " ms"); + logMessage.append("\nShortest reported query: " + this.shortestQueryTimeMs + " ms"); + logMessage.append("\nAverage query execution time: " + (this.totalQueryTimeMs / this.numberOfQueriesIssued) + " ms"); + logMessage.append("\nNumber of statements executed: " + this.numberOfQueriesIssued); + logMessage.append("\nNumber of result sets created: " + this.numberOfResultSetsCreated); + logMessage.append("\nNumber of statements prepared: " + this.numberOfPrepares); + logMessage.append("\nNumber of prepared statement executions: " + this.numberOfPreparedExecutes); + + if (this.perfMetricsHistBreakpoints != null) { + logMessage.append("\n\n\tTiming Histogram:\n"); + int maxNumPoints = 20; + int highestCount = Integer.MIN_VALUE; + + for (int i = 0; i < (HISTOGRAM_BUCKETS); i++) { + if (this.perfMetricsHistCounts[i] > highestCount) { + highestCount = this.perfMetricsHistCounts[i]; + } + } + + if (highestCount == 0) { + highestCount = 1; // avoid DIV/0 + } + + for (int i = 0; i < (HISTOGRAM_BUCKETS - 1); i++) { + + if (i == 0) { + logMessage.append("\n\tless than " + this.perfMetricsHistBreakpoints[i + 1] + " ms: \t" + this.perfMetricsHistCounts[i]); + } else { + logMessage.append("\n\tbetween " + this.perfMetricsHistBreakpoints[i] + " and " + this.perfMetricsHistBreakpoints[i + 1] + " ms: \t" + + this.perfMetricsHistCounts[i]); + } + + logMessage.append("\t"); + + int numPointsToGraph = (int) (maxNumPoints * ((double) this.perfMetricsHistCounts[i] / highestCount)); + + for (int j = 0; j < numPointsToGraph; j++) { + logMessage.append("*"); + } + + if (this.longestQueryTimeMs < this.perfMetricsHistCounts[i + 1]) { + break; + } + } + + if (this.perfMetricsHistBreakpoints[HISTOGRAM_BUCKETS - 2] < this.longestQueryTimeMs) { + logMessage.append("\n\tbetween "); + logMessage.append(this.perfMetricsHistBreakpoints[HISTOGRAM_BUCKETS - 2]); + logMessage.append(" and "); + logMessage.append(this.perfMetricsHistBreakpoints[HISTOGRAM_BUCKETS - 1]); + logMessage.append(" ms: \t"); + logMessage.append(this.perfMetricsHistCounts[HISTOGRAM_BUCKETS - 1]); + } + } + + if (this.numTablesMetricsHistBreakpoints != null) { + logMessage.append("\n\n\tTable Join Histogram:\n"); + int maxNumPoints = 20; + int highestCount = Integer.MIN_VALUE; + + for (int i = 0; i < (HISTOGRAM_BUCKETS); i++) { + if (this.numTablesMetricsHistCounts[i] > highestCount) { + highestCount = this.numTablesMetricsHistCounts[i]; + } + } + + if (highestCount == 0) { + highestCount = 1; // avoid DIV/0 + } + + for (int i = 0; i < (HISTOGRAM_BUCKETS - 1); i++) { + + if (i == 0) { + logMessage.append("\n\t" + this.numTablesMetricsHistBreakpoints[i + 1] + " tables or less: \t\t" + this.numTablesMetricsHistCounts[i]); + } else { + logMessage.append("\n\tbetween " + this.numTablesMetricsHistBreakpoints[i] + " and " + this.numTablesMetricsHistBreakpoints[i + 1] + + " tables: \t" + this.numTablesMetricsHistCounts[i]); + } + + logMessage.append("\t"); + + int numPointsToGraph = (int) (maxNumPoints * ((double) this.numTablesMetricsHistCounts[i] / highestCount)); + + for (int j = 0; j < numPointsToGraph; j++) { + logMessage.append("*"); + } + + if (this.maximumNumberTablesAccessed < this.numTablesMetricsHistBreakpoints[i + 1]) { + break; + } + } + + if (this.numTablesMetricsHistBreakpoints[HISTOGRAM_BUCKETS - 2] < this.maximumNumberTablesAccessed) { + logMessage.append("\n\tbetween "); + logMessage.append(this.numTablesMetricsHistBreakpoints[HISTOGRAM_BUCKETS - 2]); + logMessage.append(" and "); + logMessage.append(this.numTablesMetricsHistBreakpoints[HISTOGRAM_BUCKETS - 1]); + logMessage.append(" tables: "); + logMessage.append(this.numTablesMetricsHistCounts[HISTOGRAM_BUCKETS - 1]); + } + } + + log.logInfo(logMessage); + + //this.metricsLastReportedMs = System.currentTimeMillis(); + } + + ///** + // * Reports currently collected metrics if this feature is enabled and the + // * timeout has passed. + // */ + //protected void reportMetricsIfNeeded() { + // if (this.gatherPerfMetrics.getValue()) { + // if ((System.currentTimeMillis() - this.metricsLastReportedMs) > getPropertySet() + // .getIntegerReadableProperty(PropertyDefinitions.PNAME_reportMetricsIntervalMillis).getValue()) { + // reportMetrics(); + // } + // } + //} + + public void reportNumberOfTablesAccessed(int numTablesAccessed) { + if (numTablesAccessed < this.minimumNumberTablesAccessed) { + this.minimumNumberTablesAccessed = numTablesAccessed; + } + + if (numTablesAccessed > this.maximumNumberTablesAccessed) { + this.maximumNumberTablesAccessed = numTablesAccessed; + + repartitionTablesAccessedHistogram(); + } + + addToTablesAccessedHistogram(numTablesAccessed, 1); + } + + public void incrementNumberOfPreparedExecutes() { + this.numberOfPreparedExecutes++; + + // We need to increment this, because server-side prepared statements bypass any execution by the connection itself... + this.numberOfQueriesIssued++; + } + + public void incrementNumberOfPrepares() { + this.numberOfPrepares++; + } + + public void incrementNumberOfResultSetsCreated() { + this.numberOfResultSetsCreated++; + } + + public void reportQueryTime(long millisOrNanos) { + this.queryTimeCount++; + this.queryTimeSum += millisOrNanos; + this.queryTimeSumSquares += (millisOrNanos * millisOrNanos); + this.queryTimeMean = ((this.queryTimeMean * (this.queryTimeCount - 1)) + millisOrNanos) / this.queryTimeCount; + } + + /** + * Update statistics that allows the driver to determine if a query is slow enough to be logged, + * and return the estimation result for millisOrNanos value. + *

+ * Used in case autoSlowLog=true. + * + * @param millisOrNanos + * query execution time + * @return true if millisOrNanos is outside the 99th percentile? + */ + public boolean checkAbonormallyLongQuery(long millisOrNanos) { + boolean res = false; + if (this.queryTimeCount > 14) { // need a minimum amount for this to make sense + double stddev = Math.sqrt((this.queryTimeSumSquares - ((this.queryTimeSum * this.queryTimeSum) / this.queryTimeCount)) / (this.queryTimeCount - 1)); + res = millisOrNanos > (this.queryTimeMean + 5 * stddev); + } + reportQueryTime(millisOrNanos); + return res; + + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/log/LogFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/log/LogFactory.java new file mode 100644 index 0000000..8d273e0 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/log/LogFactory.java @@ -0,0 +1,95 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.log; + +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; + +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.WrongArgumentException; +import com.mysql.cj.util.Util; + +/** + * Creates instances of loggers for the driver to use. + */ +public class LogFactory { + + /** + * Returns a logger instance of the given class, with the given instance + * name. + * + * @param className + * the class to instantiate + * @param instanceName + * the instance name + * @return a logger instance + */ + public static Log getLogger(String className, String instanceName) { + + if (className == null) { + throw ExceptionFactory.createException(WrongArgumentException.class, "Logger class can not be NULL"); + } + + if (instanceName == null) { + throw ExceptionFactory.createException(WrongArgumentException.class, "Logger instance name can not be NULL"); + } + + try { + Class loggerClass = null; + + try { + loggerClass = Class.forName(className); + } catch (ClassNotFoundException nfe) { + loggerClass = Class.forName(Util.getPackageName(LogFactory.class) + "." + className); + } + + Constructor constructor = loggerClass.getConstructor(new Class[] { String.class }); + + return (Log) constructor.newInstance(new Object[] { instanceName }); + } catch (ClassNotFoundException cnfe) { + throw ExceptionFactory.createException(WrongArgumentException.class, "Unable to load class for logger '" + className + "'", cnfe); + } catch (NoSuchMethodException nsme) { + throw ExceptionFactory.createException(WrongArgumentException.class, + "Logger class does not have a single-arg constructor that takes an instance name", nsme); + } catch (InstantiationException inse) { + throw ExceptionFactory.createException(WrongArgumentException.class, + "Unable to instantiate logger class '" + className + "', exception in constructor?", inse); + } catch (InvocationTargetException ite) { + throw ExceptionFactory.createException(WrongArgumentException.class, + "Unable to instantiate logger class '" + className + "', exception in constructor?", ite); + } catch (IllegalAccessException iae) { + throw ExceptionFactory.createException(WrongArgumentException.class, + "Unable to instantiate logger class '" + className + "', constructor not public", iae); + } catch (ClassCastException cce) { + throw ExceptionFactory.createException(WrongArgumentException.class, + "Logger class '" + className + "' does not implement the '" + Log.class.getName() + "' interface", cce); + } + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/log/LoggingProfilerEventHandler.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/log/LoggingProfilerEventHandler.java new file mode 100644 index 0000000..c16d314 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/log/LoggingProfilerEventHandler.java @@ -0,0 +1,81 @@ +/* + * Copyright (c) 2007, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.log; + +import com.mysql.cj.Constants; +import com.mysql.cj.Query; +import com.mysql.cj.Session; +import com.mysql.cj.protocol.Resultset; + +/** + * A profile event handler that just logs to the standard logging mechanism of the driver. + */ +public class LoggingProfilerEventHandler implements ProfilerEventHandler { + private Log logger; + + public LoggingProfilerEventHandler() { + } + + public void consumeEvent(ProfilerEvent evt) { + switch (evt.getEventType()) { + case ProfilerEvent.TYPE_USAGE: + this.logger.logWarn(evt); + break; + + default: + this.logger.logInfo(evt); + break; + } + } + + public void destroy() { + this.logger = null; + } + + public void init(Log log) { + this.logger = log; + } + + @Override + public void processEvent(byte eventType, Session session, Query query, Resultset resultSet, long eventDuration, Throwable eventCreationPoint, + String message) { + + consumeEvent(new ProfilerEventImpl(eventType, // + session == null ? "" : session.getHostInfo().getHost(), // + session == null ? "" : session.getHostInfo().getDatabase(), // + session == null ? ProfilerEvent.NA : session.getThreadId(), // + query == null ? ProfilerEvent.NA : query.getId(), // + resultSet == null ? ProfilerEvent.NA : resultSet.getResultId(), // + eventDuration, // + session == null ? Constants.MILLIS_I18N : session.getQueryTimingUnits(), // + eventCreationPoint, message)); + + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/log/ProfilerEventImpl.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/log/ProfilerEventImpl.java new file mode 100644 index 0000000..67a2014 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/log/ProfilerEventImpl.java @@ -0,0 +1,325 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.log; + +import java.util.Date; + +import com.mysql.cj.util.LogUtils; +import com.mysql.cj.util.StringUtils; + +public class ProfilerEventImpl implements ProfilerEvent { + + private byte eventType; + private String hostName; + private String database; + private long connectionId; + private int statementId; + private int resultSetId; + private long eventCreationTime; + private long eventDuration; + private String durationUnits; + private String eventCreationPointDesc; + private String message; + + /** + * Creates a new profiler event + * + * @param eventType + * the event type (from the constants TYPE_????) + * @param hostName + * the hostname where the event occurs + * @param db + * the database in use + * @param connectionId + * the connection id (-1 if N/A) + * @param statementId + * the statement id (-1 if N/A) + * @param resultSetId + * the result set id (-1 if N/A) + * @param eventDuration + * how long did the event last? + * @param durationUnits + * time units user for eventDuration + * @param eventCreationPoint + * event creation point as a Throwable + * @param message + * optional message + */ + public ProfilerEventImpl(byte eventType, String hostName, String db, long connectionId, int statementId, int resultSetId, long eventDuration, + String durationUnits, Throwable eventCreationPoint, String message) { + this(eventType, hostName, db, connectionId, statementId, resultSetId, System.currentTimeMillis(), eventDuration, durationUnits, + LogUtils.findCallingClassAndMethod(eventCreationPoint), message); + } + + private ProfilerEventImpl(byte eventType, String hostName, String db, long connectionId, int statementId, int resultSetId, long eventCreationTime, + long eventDuration, String durationUnits, String eventCreationPointDesc, String message) { + // null-strings are stored as empty strings to get consistent results with pack/unpack + this.eventType = eventType; + this.hostName = hostName == null ? "" : hostName; + this.database = db == null ? "" : db; + this.connectionId = connectionId; + this.statementId = statementId; + this.resultSetId = resultSetId; + this.eventCreationTime = eventCreationTime; + this.eventDuration = eventDuration; + this.durationUnits = durationUnits == null ? "" : durationUnits; + this.eventCreationPointDesc = eventCreationPointDesc == null ? "" : eventCreationPointDesc; + this.message = message == null ? "" : message; + } + + @Override + public byte getEventType() { + return this.eventType; + } + + @Override + public String getHostName() { + return this.hostName; + } + + @Override + public String getDatabase() { + return this.database; + } + + @Override + public long getConnectionId() { + return this.connectionId; + } + + @Override + public int getStatementId() { + return this.statementId; + } + + @Override + public int getResultSetId() { + return this.resultSetId; + } + + @Override + public long getEventCreationTime() { + return this.eventCreationTime; + } + + @Override + public long getEventDuration() { + return this.eventDuration; + } + + @Override + public String getDurationUnits() { + return this.durationUnits; + } + + @Override + public String getEventCreationPointAsString() { + return this.eventCreationPointDesc; + } + + @Override + public String getMessage() { + return this.message; + } + + /** + * Returns a representation of this event as a String. + * + * @return a String representation of this event. + */ + @Override + public String toString() { + StringBuilder buf = new StringBuilder(); + buf.append("["); + + switch (this.getEventType()) { + case TYPE_EXECUTE: + buf.append("EXECUTE"); + break; + case TYPE_FETCH: + buf.append("FETCH"); + break; + case TYPE_OBJECT_CREATION: + buf.append("CONSTRUCT"); + break; + case TYPE_PREPARE: + buf.append("PREPARE"); + break; + case TYPE_QUERY: + buf.append("QUERY"); + break; + case TYPE_USAGE: + buf.append("USAGE ADVISOR"); + break; + case TYPE_SLOW_QUERY: + buf.append("SLOW QUERY"); + break; + default: + buf.append("UNKNOWN"); + } + buf.append("] "); + + buf.append(this.message); + + buf.append(" [Created on: "); + buf.append(new Date(this.eventCreationTime)); + buf.append(", duration: "); + buf.append(this.eventDuration); + buf.append(", connection-id: "); + buf.append(this.connectionId); + buf.append(", statement-id: "); + buf.append(this.statementId); + buf.append(", resultset-id: "); + buf.append(this.resultSetId); + buf.append(","); + buf.append(this.eventCreationPointDesc); + buf.append("]"); + + return buf.toString(); + } + + /** + * Unpacks a binary representation of this event. + * + * @param buf + * the binary representation of this event + * @return the unpacked Event + */ + public static ProfilerEvent unpack(byte[] buf) { + int pos = 0; + + byte eventType = buf[pos++]; + + byte[] host = readBytes(buf, pos); + pos += 4 + host.length; + + byte[] db = readBytes(buf, pos); + pos += 4 + db.length; + + long connectionId = readLong(buf, pos); + pos += 8; + int statementId = readInt(buf, pos); + pos += 4; + int resultSetId = readInt(buf, pos); + pos += 4; + long eventCreationTime = readLong(buf, pos); + pos += 8; + long eventDuration = readLong(buf, pos); + pos += 8; + + byte[] eventDurationUnits = readBytes(buf, pos); + pos += 4 + eventDurationUnits.length; + + byte[] eventCreationAsBytes = readBytes(buf, pos); + pos += 4 + eventCreationAsBytes.length; + + byte[] message = readBytes(buf, pos); + pos += 4 + message.length; + + // TODO charset? + return new ProfilerEventImpl(eventType, StringUtils.toString(host, "ISO8859_1"), StringUtils.toString(db, "ISO8859_1"), connectionId, statementId, + resultSetId, eventCreationTime, eventDuration, StringUtils.toString(eventDurationUnits, "ISO8859_1"), + StringUtils.toString(eventCreationAsBytes, "ISO8859_1"), StringUtils.toString(message, "ISO8859_1")); + } + + public byte[] pack() { + + // TODO charset (Bug#41172 ?) + byte[] hostNameAsBytes = StringUtils.getBytes(this.hostName, "ISO8859_1"); + byte[] dbAsBytes = StringUtils.getBytes(this.database, "ISO8859_1"); + byte[] durationUnitsAsBytes = StringUtils.getBytes(this.durationUnits, "ISO8859_1"); + byte[] eventCreationAsBytes = StringUtils.getBytes(this.eventCreationPointDesc, "ISO8859_1"); + byte[] messageAsBytes = StringUtils.getBytes(this.message, "ISO8859_1"); + + int len = /* eventType */ 1 + /* hostName */ (4 + hostNameAsBytes.length) + + /* db */ (4 + dbAsBytes.length) + /* connectionId */ 8 + + /* statementId */ 4 + /* resultSetId */ 4 + /* eventCreationTime */ 8 + /* eventDuration */ 8 + + /* durationUnits */ (4 + durationUnitsAsBytes.length) + /* eventCreationPointDesc */ (4 + eventCreationAsBytes.length) + + /* message */ (4 + messageAsBytes.length); + + byte[] buf = new byte[len]; + int pos = 0; + buf[pos++] = this.eventType; + pos = writeBytes(hostNameAsBytes, buf, pos); + pos = writeBytes(dbAsBytes, buf, pos); + pos = writeLong(this.connectionId, buf, pos); + pos = writeInt(this.statementId, buf, pos); + pos = writeInt(this.resultSetId, buf, pos); + pos = writeLong(this.eventCreationTime, buf, pos); + pos = writeLong(this.eventDuration, buf, pos); + pos = writeBytes(durationUnitsAsBytes, buf, pos); + pos = writeBytes(eventCreationAsBytes, buf, pos); + pos = writeBytes(messageAsBytes, buf, pos); + + return buf; + } + + private static int writeInt(int i, byte[] buf, int pos) { + buf[pos++] = (byte) (i & 0xff); + buf[pos++] = (byte) (i >>> 8); + buf[pos++] = (byte) (i >>> 16); + buf[pos++] = (byte) (i >>> 24); + return pos; + } + + private static int writeLong(long l, byte[] buf, int pos) { + buf[pos++] = (byte) (l & 0xff); + buf[pos++] = (byte) (l >>> 8); + buf[pos++] = (byte) (l >>> 16); + buf[pos++] = (byte) (l >>> 24); + buf[pos++] = (byte) (l >>> 32); + buf[pos++] = (byte) (l >>> 40); + buf[pos++] = (byte) (l >>> 48); + buf[pos++] = (byte) (l >>> 56); + return pos; + } + + private static int writeBytes(byte[] msg, byte[] buf, int pos) { + pos = writeInt(msg.length, buf, pos); + System.arraycopy(msg, 0, buf, pos, msg.length); + return pos + msg.length; + } + + private static int readInt(byte[] buf, int pos) { + return (buf[pos++] & 0xff) | ((buf[pos++] & 0xff) << 8) | ((buf[pos++] & 0xff) << 16) | ((buf[pos++] & 0xff) << 24); + } + + private static long readLong(byte[] buf, int pos) { + return (buf[pos++] & 0xff) | ((long) (buf[pos++] & 0xff) << 8) | ((long) (buf[pos++] & 0xff) << 16) | ((long) (buf[pos++] & 0xff) << 24) + | ((long) (buf[pos++] & 0xff) << 32) | ((long) (buf[pos++] & 0xff) << 40) | ((long) (buf[pos++] & 0xff) << 48) + | ((long) (buf[pos++] & 0xff) << 56); + } + + private static byte[] readBytes(byte[] buf, int pos) { + int length = readInt(buf, pos); + byte[] msg = new byte[length]; + System.arraycopy(buf, pos + 4, msg, 0, length); + return msg; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/AbstractProtocol.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/AbstractProtocol.java new file mode 100644 index 0000000..704d559 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/AbstractProtocol.java @@ -0,0 +1,172 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.lang.ref.WeakReference; +import java.util.LinkedList; +import java.util.concurrent.CopyOnWriteArrayList; + +import com.mysql.cj.MessageBuilder; +import com.mysql.cj.Messages; +import com.mysql.cj.Session; +import com.mysql.cj.TransactionEventHandler; +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.ExceptionInterceptor; +import com.mysql.cj.log.Log; +import com.mysql.cj.protocol.Protocol.ProtocolEventHandler; +import com.mysql.cj.protocol.Protocol.ProtocolEventListener.EventType; +import com.mysql.cj.util.TimeUtil; + +public abstract class AbstractProtocol implements Protocol, ProtocolEventHandler { + + protected Session session; + protected SocketConnection socketConnection; + + protected PropertySet propertySet; + + protected TransactionEventHandler transactionManager; + + /** The logger we're going to use */ + protected transient Log log; + + protected ExceptionInterceptor exceptionInterceptor; + + protected AuthenticationProvider authProvider; + + protected MessageBuilder messageBuilder; + + // Default until packet sender created + private PacketSentTimeHolder packetSentTimeHolder = new PacketSentTimeHolder() { + }; + private PacketReceivedTimeHolder packetReceivedTimeHolder = new PacketReceivedTimeHolder() { + }; + + protected LinkedList packetDebugRingBuffer = null; + + protected boolean useNanosForElapsedTime; + protected String queryTimingUnits; + + private CopyOnWriteArrayList> listeners = new CopyOnWriteArrayList<>(); + + @Override + public void init(Session sess, SocketConnection phConnection, PropertySet propSet, TransactionEventHandler trManager) { + this.session = sess; + this.propertySet = propSet; + + this.socketConnection = phConnection; + this.exceptionInterceptor = this.socketConnection.getExceptionInterceptor(); + + this.transactionManager = trManager; + + this.useNanosForElapsedTime = this.propertySet.getBooleanProperty(PropertyKey.useNanosForElapsedTime).getValue() && TimeUtil.nanoTimeAvailable(); + this.queryTimingUnits = this.useNanosForElapsedTime ? Messages.getString("Nanoseconds") : Messages.getString("Milliseconds"); + + } + + public SocketConnection getSocketConnection() { + return this.socketConnection; + } + + public AuthenticationProvider getAuthenticationProvider() { + return this.authProvider; + } + + public ExceptionInterceptor getExceptionInterceptor() { + return this.exceptionInterceptor; + } + + public PacketSentTimeHolder getPacketSentTimeHolder() { + return this.packetSentTimeHolder; + } + + public void setPacketSentTimeHolder(PacketSentTimeHolder packetSentTimeHolder) { + this.packetSentTimeHolder = packetSentTimeHolder; + } + + public PacketReceivedTimeHolder getPacketReceivedTimeHolder() { + return this.packetReceivedTimeHolder; + } + + public void setPacketReceivedTimeHolder(PacketReceivedTimeHolder packetReceivedTimeHolder) { + this.packetReceivedTimeHolder = packetReceivedTimeHolder; + } + + public PropertySet getPropertySet() { + return this.propertySet; + } + + public void setPropertySet(PropertySet propertySet) { + this.propertySet = propertySet; + } + + @Override + public MessageBuilder getMessageBuilder() { + return this.messageBuilder; + } + + @Override + public void reset() { + // no-op + } + + @Override + public String getQueryTimingUnits() { + return this.queryTimingUnits; + } + + @Override + public void addListener(ProtocolEventListener l) { + this.listeners.addIfAbsent(new WeakReference<>(l)); + } + + @Override + public void removeListener(ProtocolEventListener listener) { + for (WeakReference wr : this.listeners) { + ProtocolEventListener l = wr.get(); + if (l == listener) { + this.listeners.remove(wr); + break; + } + } + } + + @Override + public void invokeListeners(EventType type, Throwable reason) { + for (WeakReference wr : this.listeners) { + ProtocolEventListener l = wr.get(); + if (l != null) { + l.handleEvent(type, this, reason); + } else { + this.listeners.remove(wr); + } + } + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/AbstractSocketConnection.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/AbstractSocketConnection.java new file mode 100644 index 0000000..bca7532 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/AbstractSocketConnection.java @@ -0,0 +1,144 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.io.BufferedOutputStream; +import java.io.IOException; +import java.net.Socket; + +import com.mysql.cj.Messages; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.CJException; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.ExceptionInterceptor; +import com.mysql.cj.exceptions.UnableToConnectException; +import com.mysql.jdbc.SocketFactoryWrapper; + +public abstract class AbstractSocketConnection implements SocketConnection { + + protected String host = null; + protected int port = 3306; + protected SocketFactory socketFactory = null; + protected Socket mysqlSocket = null; + protected FullReadInputStream mysqlInput = null; + protected BufferedOutputStream mysqlOutput = null; + + protected ExceptionInterceptor exceptionInterceptor; + protected PropertySet propertySet; + + public String getHost() { + return this.host; + } + + public int getPort() { + return this.port; + } + + public Socket getMysqlSocket() { + return this.mysqlSocket; + } + + public FullReadInputStream getMysqlInput() throws IOException { + if (this.mysqlInput != null) { + return this.mysqlInput; + } + throw new IOException(Messages.getString("SocketConnection.2")); + } + + public void setMysqlInput(FullReadInputStream mysqlInput) { + this.mysqlInput = mysqlInput; + } + + public BufferedOutputStream getMysqlOutput() throws IOException { + if (this.mysqlOutput != null) { + return this.mysqlOutput; + } + throw new IOException(Messages.getString("SocketConnection.2")); + } + + public boolean isSSLEstablished() { + return ExportControlled.enabled() && ExportControlled.isSSLEstablished(this.getMysqlSocket()); + } + + public SocketFactory getSocketFactory() { + return this.socketFactory; + } + + public void setSocketFactory(SocketFactory socketFactory) { + this.socketFactory = socketFactory; + } + + /** + * Forcibly closes the underlying socket to MySQL. + */ + public void forceClose() { + try { + getNetworkResources().forceClose(); + } finally { + this.mysqlSocket = null; + this.mysqlInput = null; + this.mysqlOutput = null; + } + } + + // We do this to break the chain between MysqlIO and Connection, so that we can have PhantomReferences on connections that let the driver clean up the + // socket connection without having to use finalize() somewhere (which although more straightforward, is horribly inefficient). + public NetworkResources getNetworkResources() { + return new NetworkResources(this.mysqlSocket, this.mysqlInput, this.mysqlOutput); + } + + public ExceptionInterceptor getExceptionInterceptor() { + return this.exceptionInterceptor; + } + + public PropertySet getPropertySet() { + return this.propertySet; + } + + protected SocketFactory createSocketFactory(String socketFactoryClassName) { + try { + if (socketFactoryClassName == null) { + throw ExceptionFactory.createException(UnableToConnectException.class, Messages.getString("SocketConnection.0"), getExceptionInterceptor()); + } + + Object sf = Class.forName(socketFactoryClassName).newInstance(); + if (sf instanceof SocketFactory) { + return (SocketFactory) (Class.forName(socketFactoryClassName).newInstance()); + } + + // wrap legacy socket factories + return new SocketFactoryWrapper(sf); + } catch (InstantiationException | IllegalAccessException | ClassNotFoundException | CJException ex) { + throw ExceptionFactory.createException(UnableToConnectException.class, + Messages.getString("SocketConnection.1", new String[] { socketFactoryClassName }), getExceptionInterceptor()); + } + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/ExportControlled.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/ExportControlled.java new file mode 100644 index 0000000..d1798c6 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/ExportControlled.java @@ -0,0 +1,679 @@ +/* + * Copyright (c) 2002, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.io.IOException; +import java.io.InputStream; +import java.net.MalformedURLException; +import java.net.Socket; +import java.net.URL; +import java.security.InvalidAlgorithmParameterException; +import java.security.InvalidKeyException; +import java.security.KeyFactory; +import java.security.KeyManagementException; +import java.security.KeyStore; +import java.security.KeyStoreException; +import java.security.NoSuchAlgorithmException; +import java.security.UnrecoverableKeyException; +import java.security.cert.CertPath; +import java.security.cert.CertPathValidator; +import java.security.cert.CertPathValidatorException; +import java.security.cert.CertPathValidatorResult; +import java.security.cert.CertificateException; +import java.security.cert.CertificateFactory; +import java.security.cert.PKIXCertPathValidatorResult; +import java.security.cert.PKIXParameters; +import java.security.cert.TrustAnchor; +import java.security.cert.X509CertSelector; +import java.security.cert.X509Certificate; +import java.security.interfaces.RSAPublicKey; +import java.security.spec.InvalidKeySpecException; +import java.security.spec.X509EncodedKeySpec; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.List; +import java.util.Properties; +import java.util.Set; +import java.util.stream.Collectors; +import java.util.stream.Stream; + +import javax.crypto.BadPaddingException; +import javax.crypto.Cipher; +import javax.crypto.IllegalBlockSizeException; +import javax.crypto.NoSuchPaddingException; +import javax.naming.InvalidNameException; +import javax.naming.ldap.LdapName; +import javax.naming.ldap.Rdn; +import javax.net.ssl.KeyManager; +import javax.net.ssl.KeyManagerFactory; +import javax.net.ssl.SSLContext; +import javax.net.ssl.SSLSocket; +import javax.net.ssl.SSLSocketFactory; +import javax.net.ssl.TrustManager; +import javax.net.ssl.TrustManagerFactory; +import javax.net.ssl.X509TrustManager; +import javax.security.auth.x500.X500Principal; + +import com.mysql.cj.ServerVersion; +import com.mysql.cj.conf.PropertyDefinitions; +import com.mysql.cj.conf.PropertyDefinitions.SslMode; +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.CJCommunicationsException; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.ExceptionInterceptor; +import com.mysql.cj.exceptions.FeatureNotAvailableException; +import com.mysql.cj.exceptions.RSAException; +import com.mysql.cj.exceptions.SSLParamsException; +import com.mysql.cj.exceptions.WrongArgumentException; +import com.mysql.cj.log.Log; +import com.mysql.cj.util.Base64Decoder; +import com.mysql.cj.util.StringUtils; +import com.mysql.cj.util.Util; + +/** + * Holds functionality that falls under export-control regulations. + */ +public class ExportControlled { + private static final String TLSv1 = "TLSv1"; + private static final String TLSv1_1 = "TLSv1.1"; + private static final String TLSv1_2 = "TLSv1.2"; + private static final String TLSv1_3 = "TLSv1.3"; + private static final String[] TLS_PROTOCOLS = new String[] { TLSv1_3, TLSv1_2, TLSv1_1, TLSv1 }; + + private static final String TLS_SETTINGS_RESOURCE = "/com/mysql/cj/TlsSettings.properties"; + private static final List ALLOWED_CIPHERS = new ArrayList<>(); + private static final List RESTRICTED_CIPHER_SUBSTR = new ArrayList<>(); + + static { + try { + Properties tlsSettings = new Properties(); + tlsSettings.load(ExportControlled.class.getResourceAsStream(TLS_SETTINGS_RESOURCE)); + Arrays.stream(tlsSettings.getProperty("TLSCiphers.Mandatory").split("\\s*,\\s*")).forEach(s -> ALLOWED_CIPHERS.add(s.trim())); + Arrays.stream(tlsSettings.getProperty("TLSCiphers.Approved").split("\\s*,\\s*")).forEach(s -> ALLOWED_CIPHERS.add(s.trim())); + Arrays.stream(tlsSettings.getProperty("TLSCiphers.Deprecated").split("\\s*,\\s*")).forEach(s -> ALLOWED_CIPHERS.add(s.trim())); + Arrays.stream(tlsSettings.getProperty("TLSCiphers.Unacceptable.Mask").split("\\s*,\\s*")).forEach(s -> RESTRICTED_CIPHER_SUBSTR.add(s.trim())); + } catch (IOException e) { + throw ExceptionFactory.createException("Unable to load TlsSettings.properties"); + } + } + + private ExportControlled() { /* prevent instantiation */ + } + + public static boolean enabled() { + // we may wish to un-static-ify this class this static method call may be removed entirely by the compiler + return true; + } + + private static String[] getAllowedCiphers(PropertySet pset, List socketCipherSuites) { + String enabledSSLCipherSuites = pset.getStringProperty(PropertyKey.enabledSSLCipherSuites).getValue(); + Stream filterStream = StringUtils.isNullOrEmpty(enabledSSLCipherSuites) ? socketCipherSuites.stream() + : Arrays.stream(enabledSSLCipherSuites.split("\\s*,\\s*")).filter(socketCipherSuites::contains); + + List allowedCiphers = filterStream + // mandatory, approved and deprecated ciphers + .filter(ALLOWED_CIPHERS::contains) + // unacceptable ciphers + .filter(c -> !RESTRICTED_CIPHER_SUBSTR.stream().filter(r -> c.contains(r)).findFirst().isPresent()) + // + .collect(Collectors.toList()); + + return allowedCiphers.toArray(new String[] {}); + } + + private static String[] getAllowedProtocols(PropertySet pset, ServerVersion serverVersion, String[] socketProtocols) { + String[] tryProtocols = null; + + // If enabledTLSProtocols configuration option is set, overriding the default TLS version restrictions. + // This allows enabling TLSv1.2 for self-compiled MySQL versions supporting it, as well as the ability + // for users to restrict TLS connections to approved protocols (e.g., prohibiting TLSv1) on the client side. + String enabledTLSProtocols = pset.getStringProperty(PropertyKey.enabledTLSProtocols).getValue(); + if (enabledTLSProtocols != null && enabledTLSProtocols.length() > 0) { + tryProtocols = enabledTLSProtocols.split("\\s*,\\s*"); + } + // It is problematic to enable TLSv1.2 on the client side when the server is compiled with yaSSL. When client attempts to connect with + // TLSv1.2 yaSSL just closes the socket instead of re-attempting handshake with lower TLS version. So here we allow all protocols only + // for server versions which are known to be compiled with OpenSSL. + else if (serverVersion == null) { + // X Protocol doesn't provide server version, but we prefer to use most recent TLS version, though it also means that X Protocol + // connection to old MySQL 5.7 GPL releases will fail by default, user must use enabledTLSProtocols=TLSv1.1 to connect them. + tryProtocols = TLS_PROTOCOLS; + } else if (serverVersion.meetsMinimum(new ServerVersion(5, 7, 28)) + || serverVersion.meetsMinimum(new ServerVersion(5, 6, 46)) && !serverVersion.meetsMinimum(new ServerVersion(5, 7, 0)) + || serverVersion.meetsMinimum(new ServerVersion(5, 6, 0)) && Util.isEnterpriseEdition(serverVersion.toString())) { + tryProtocols = TLS_PROTOCOLS; + } else { + // allow only TLSv1 and TLSv1.1 for other server versions by default + tryProtocols = new String[] { TLSv1_1, TLSv1 }; + } + + List configuredProtocols = new ArrayList<>(Arrays.asList(tryProtocols)); + List jvmSupportedProtocols = Arrays.asList(socketProtocols); + + List allowedProtocols = new ArrayList<>(); + for (String protocol : TLS_PROTOCOLS) { + if (jvmSupportedProtocols.contains(protocol) && configuredProtocols.contains(protocol)) { + allowedProtocols.add(protocol); + } + } + return allowedProtocols.toArray(new String[0]); + + } + + public static void checkValidProtocols(List protocols) { + List validProtocols = Arrays.asList(TLS_PROTOCOLS); + for (String protocol : protocols) { + if (!validProtocols.contains(protocol)) { + throw ExceptionFactory.createException(WrongArgumentException.class, + "'" + protocol + "' not recognized as a valid TLS protocol version (should be one of " + + Arrays.stream(TLS_PROTOCOLS).collect(Collectors.joining(", ")) + ")."); + } + } + } + + private static class KeyStoreConf { + public String keyStoreUrl = null; + public String keyStorePassword = null; + public String keyStoreType = "JKS"; + + public KeyStoreConf() { + } + + public KeyStoreConf(String keyStoreUrl, String keyStorePassword, String keyStoreType) { + this.keyStoreUrl = keyStoreUrl; + this.keyStorePassword = keyStorePassword; + this.keyStoreType = keyStoreType; + } + } + + private static KeyStoreConf getTrustStoreConf(PropertySet propertySet, boolean required) { + String trustStoreUrl = propertySet.getStringProperty(PropertyKey.trustCertificateKeyStoreUrl).getValue(); + String trustStorePassword = propertySet.getStringProperty(PropertyKey.trustCertificateKeyStorePassword).getValue(); + String trustStoreType = propertySet.getStringProperty(PropertyKey.trustCertificateKeyStoreType).getValue(); + boolean fallbackToSystemTrustStore = propertySet.getBooleanProperty(PropertyKey.fallbackToSystemTrustStore).getValue(); + + if (fallbackToSystemTrustStore && StringUtils.isNullOrEmpty(trustStoreUrl)) { + trustStoreUrl = System.getProperty("javax.net.ssl.trustStore"); + trustStorePassword = System.getProperty("javax.net.ssl.trustStorePassword"); + trustStoreType = System.getProperty("javax.net.ssl.trustStoreType"); + if (StringUtils.isNullOrEmpty(trustStoreType)) { + trustStoreType = propertySet.getStringProperty(PropertyKey.trustCertificateKeyStoreType).getInitialValue(); + } + // check URL + if (!StringUtils.isNullOrEmpty(trustStoreUrl)) { + try { + new URL(trustStoreUrl); + } catch (MalformedURLException e) { + trustStoreUrl = "file:" + trustStoreUrl; + } + } + } + + if (required && StringUtils.isNullOrEmpty(trustStoreUrl)) { + throw new CJCommunicationsException("No truststore provided to verify the Server certificate."); + } + + return new KeyStoreConf(trustStoreUrl, trustStorePassword, trustStoreType); + } + + private static KeyStoreConf getKeyStoreConf(PropertySet propertySet) { + String keyStoreUrl = propertySet.getStringProperty(PropertyKey.clientCertificateKeyStoreUrl).getValue(); + String keyStorePassword = propertySet.getStringProperty(PropertyKey.clientCertificateKeyStorePassword).getValue(); + String keyStoreType = propertySet.getStringProperty(PropertyKey.clientCertificateKeyStoreType).getValue(); + boolean fallbackToSystemKeyStore = propertySet.getBooleanProperty(PropertyKey.fallbackToSystemKeyStore).getValue(); + + if (fallbackToSystemKeyStore && StringUtils.isNullOrEmpty(keyStoreUrl)) { + keyStoreUrl = System.getProperty("javax.net.ssl.keyStore"); + keyStorePassword = System.getProperty("javax.net.ssl.keyStorePassword"); + keyStoreType = System.getProperty("javax.net.ssl.keyStoreType"); + if (StringUtils.isNullOrEmpty(keyStoreType)) { + keyStoreType = propertySet.getStringProperty(PropertyKey.clientCertificateKeyStoreType).getInitialValue(); + } + // check URL + if (!StringUtils.isNullOrEmpty(keyStoreUrl)) { + try { + new URL(keyStoreUrl); + } catch (MalformedURLException e) { + keyStoreUrl = "file:" + keyStoreUrl; + } + } + } + + return new KeyStoreConf(keyStoreUrl, keyStorePassword, keyStoreType); + } + + /** + * Converts the socket being used in the given SocketConnection to an SSLSocket by performing the SSL/TLS handshake. + * + * @param rawSocket + * original non-SSL socket + * @param socketConnection + * the Protocol instance containing the socket to convert to an SSLSocket. + * @param serverVersion + * ServerVersion object + * @param log + * Logger + * @return SSL socket + * @throws IOException + * if i/o exception occurs + * @throws SSLParamsException + * if the handshake fails, or if this distribution of Connector/J doesn't contain the SSL crypto hooks needed to perform the handshake. + * @throws FeatureNotAvailableException + * if TLS is not supported + */ + public static Socket performTlsHandshake(Socket rawSocket, SocketConnection socketConnection, ServerVersion serverVersion, Log log) + throws IOException, SSLParamsException, FeatureNotAvailableException { + PropertySet pset = socketConnection.getPropertySet(); + + SslMode sslMode = pset.getEnumProperty(PropertyKey.sslMode).getValue(); + boolean verifyServerCert = sslMode == SslMode.VERIFY_CA || sslMode == SslMode.VERIFY_IDENTITY; + boolean fallbackToSystemTrustStore = pset.getBooleanProperty(PropertyKey.fallbackToSystemTrustStore).getValue(); + + // (serverVersion == null) means that it was called from the X DevAPI. + KeyStoreConf trustStore = !verifyServerCert ? new KeyStoreConf() + : getTrustStoreConf(pset, serverVersion == null && verifyServerCert && !fallbackToSystemTrustStore); + KeyStoreConf keyStore = getKeyStoreConf(pset); + + SSLSocketFactory socketFactory = getSSLContext(keyStore, trustStore, fallbackToSystemTrustStore, verifyServerCert, + sslMode == PropertyDefinitions.SslMode.VERIFY_IDENTITY ? socketConnection.getHost() : null, socketConnection.getExceptionInterceptor()) + .getSocketFactory(); + + SSLSocket sslSocket = (SSLSocket) socketFactory.createSocket(rawSocket, socketConnection.getHost(), socketConnection.getPort(), true); + + String[] allowedProtocols = getAllowedProtocols(pset, serverVersion, sslSocket.getSupportedProtocols()); + sslSocket.setEnabledProtocols(allowedProtocols); + + String[] allowedCiphers = getAllowedCiphers(pset, Arrays.asList(sslSocket.getEnabledCipherSuites())); + if (allowedCiphers != null) { + sslSocket.setEnabledCipherSuites(allowedCiphers); + } + + sslSocket.startHandshake(); + + if (log != null) { + String tlsVersion = sslSocket.getSession().getProtocol(); + if (TLSv1.equalsIgnoreCase(tlsVersion) || TLSv1_1.equalsIgnoreCase(tlsVersion)) { + log.logWarn("This connection is using " + tlsVersion + " which is now deprecated and will be removed in a future release of Connector/J."); + } + } + + return sslSocket; + } + + /** + * Implementation of X509TrustManager wrapping JVM X509TrustManagers to add expiration and identity check + */ + public static class X509TrustManagerWrapper implements X509TrustManager { + private X509TrustManager origTm = null; + private boolean verifyServerCert = false; + private String hostName = null; + private CertificateFactory certFactory = null; + private PKIXParameters validatorParams = null; + private CertPathValidator validator = null; + + public X509TrustManagerWrapper(X509TrustManager tm, boolean verifyServerCertificate, String hostName) throws CertificateException { + this.origTm = tm; + this.verifyServerCert = verifyServerCertificate; + this.hostName = hostName; + + if (verifyServerCertificate) { + try { + Set anch = Arrays.stream(tm.getAcceptedIssuers()).map(c -> new TrustAnchor(c, null)).collect(Collectors.toSet()); + this.validatorParams = new PKIXParameters(anch); + this.validatorParams.setRevocationEnabled(false); + this.validator = CertPathValidator.getInstance("PKIX"); + this.certFactory = CertificateFactory.getInstance("X.509"); + } catch (Exception e) { + throw new CertificateException(e); + } + } + + } + + public X509TrustManagerWrapper(boolean verifyServerCertificate, String hostName) { + this.verifyServerCert = verifyServerCertificate; + this.hostName = hostName; + } + + public X509Certificate[] getAcceptedIssuers() { + return this.origTm != null ? this.origTm.getAcceptedIssuers() : new X509Certificate[0]; + } + + public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException { + for (int i = 0; i < chain.length; i++) { + chain[i].checkValidity(); + } + + if (this.validatorParams != null) { + X509CertSelector certSelect = new X509CertSelector(); + certSelect.setSerialNumber(chain[0].getSerialNumber()); + + try { + CertPath certPath = this.certFactory.generateCertPath(Arrays.asList(chain)); + // Validate against the truststore. + CertPathValidatorResult result = this.validator.validate(certPath, this.validatorParams); + // Check expiration for the CA used to validate this path. + ((PKIXCertPathValidatorResult) result).getTrustAnchor().getTrustedCert().checkValidity(); + } catch (InvalidAlgorithmParameterException e) { + throw new CertificateException(e); + } catch (CertPathValidatorException e) { + throw new CertificateException(e); + } + } + + if (this.verifyServerCert) { + if (this.origTm != null) { + this.origTm.checkServerTrusted(chain, authType); + } else { + throw new CertificateException("Can't verify server certificate because no trust manager is found."); + } + + // Validate server identity. + if (this.hostName != null) { + boolean hostNameVerified = false; + + // Check each one of the DNS-ID (or IP) entries from the certificate 'subjectAltName' field. + // See https://tools.ietf.org/html/rfc6125#section-6.4 and https://tools.ietf.org/html/rfc2818#section-3.1 + final Collection> subjectAltNames = chain[0].getSubjectAlternativeNames(); + if (subjectAltNames != null) { + boolean sanVerification = false; + for (final List san : subjectAltNames) { + final Integer nameType = (Integer) san.get(0); + // dNSName [2] IA5String + // iPAddress [7] OCTET STRING + if (nameType == 2) { + sanVerification = true; + if (verifyHostName((String) san.get(1))) { // May contain a wildcard char. + // Host name is valid. + hostNameVerified = true; + break; + } + } else if (nameType == 7) { + sanVerification = true; + if (this.hostName.equalsIgnoreCase((String) san.get(1))) { + // Host name (IP) is valid. + hostNameVerified = true; + break; + } + } + } + if (sanVerification && !hostNameVerified) { + throw new CertificateException("Server identity verification failed. " + + "None of the DNS or IP Subject Alternative Name entries matched the server hostname/IP '" + this.hostName + "'."); + } + } + + if (!hostNameVerified) { + // Fall-back to checking the Relative Distinguished Name CN-ID (Common Name/CN) from the certificate 'subject' field. + // https://tools.ietf.org/html/rfc6125#section-6.4.4 + final String dn = chain[0].getSubjectX500Principal().getName(X500Principal.RFC2253); + String cn = null; + try { + LdapName ldapDN = new LdapName(dn); + for (Rdn rdn : ldapDN.getRdns()) { + if (rdn.getType().equalsIgnoreCase("CN")) { + cn = rdn.getValue().toString(); + break; + } + } + } catch (InvalidNameException e) { + throw new CertificateException("Failed to retrieve the Common Name (CN) from the server certificate."); + } + + if (!verifyHostName(cn)) { + throw new CertificateException( + "Server identity verification failed. The certificate Common Name '" + cn + "' does not match '" + this.hostName + "'."); + } + } + } + } + + // Nothing else to validate. + } + + public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException { + this.origTm.checkClientTrusted(chain, authType); + } + + /** + * Verify the host name against the given pattern, using the rules specified in RFC 6125, + * Section 6.4.3. Support wildcard character as defined in the RFC. + * + * @param ptn + * the pattern to match with the host name. + * @return + * true if the host name matches the pattern, false otherwise. + */ + private boolean verifyHostName(String ptn) { + final int indexOfStar = ptn.indexOf('*'); + if (indexOfStar >= 0 && indexOfStar < ptn.indexOf('.')) { + final String head = ptn.substring(0, indexOfStar); + final String tail = ptn.substring(indexOfStar + 1); + + return StringUtils.startsWithIgnoreCase(this.hostName, head) && StringUtils.endsWithIgnoreCase(this.hostName, tail) + && this.hostName.substring(head.length(), this.hostName.length() - tail.length()).indexOf('.') == -1; + } + return this.hostName.equalsIgnoreCase(ptn); + } + } + + /** + * Configure the {@link SSLContext} based on the supplier property set. + * + * @param clientCertificateKeyStore + * clientCertificateKeyStore + * @param trustCertificateKeyStore + * trustCertificateKeyStore + * @param fallbackToDefaultTrustStore + * fallbackToDefaultTrustStore + * @param verifyServerCert + * verifyServerCert + * @param hostName + * host name + * @param exceptionInterceptor + * exception interceptor + * @return SSLContext + * @throws SSLParamsException + * if an error occurs + */ + public static SSLContext getSSLContext(KeyStoreConf clientCertificateKeyStore, KeyStoreConf trustCertificateKeyStore, boolean fallbackToDefaultTrustStore, + boolean verifyServerCert, String hostName, ExceptionInterceptor exceptionInterceptor) throws SSLParamsException { + String clientCertificateKeyStoreUrl = clientCertificateKeyStore.keyStoreUrl; + String clientCertificateKeyStoreType = clientCertificateKeyStore.keyStoreType; + String clientCertificateKeyStorePassword = clientCertificateKeyStore.keyStorePassword; + String trustCertificateKeyStoreUrl = trustCertificateKeyStore.keyStoreUrl; + String trustCertificateKeyStoreType = trustCertificateKeyStore.keyStoreType; + String trustCertificateKeyStorePassword = trustCertificateKeyStore.keyStorePassword; + + TrustManagerFactory tmf = null; + KeyManagerFactory kmf = null; + + KeyManager[] kms = null; + List tms = new ArrayList<>(); + + try { + tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm()); + kmf = KeyManagerFactory.getInstance(KeyManagerFactory.getDefaultAlgorithm()); + } catch (NoSuchAlgorithmException nsae) { + throw ExceptionFactory.createException(SSLParamsException.class, + "Default algorithm definitions for TrustManager and/or KeyManager are invalid. Check java security properties file.", nsae, + exceptionInterceptor); + } + + if (!StringUtils.isNullOrEmpty(clientCertificateKeyStoreUrl)) { + InputStream ksIS = null; + try { + if (!StringUtils.isNullOrEmpty(clientCertificateKeyStoreType)) { + KeyStore clientKeyStore = KeyStore.getInstance(clientCertificateKeyStoreType); + URL ksURL = new URL(clientCertificateKeyStoreUrl); + char[] password = (clientCertificateKeyStorePassword == null) ? new char[0] : clientCertificateKeyStorePassword.toCharArray(); + ksIS = ksURL.openStream(); + clientKeyStore.load(ksIS, password); + kmf.init(clientKeyStore, password); + kms = kmf.getKeyManagers(); + } + } catch (UnrecoverableKeyException uke) { + throw ExceptionFactory.createException(SSLParamsException.class, "Could not recover keys from client keystore. Check password?", uke, + exceptionInterceptor); + } catch (NoSuchAlgorithmException nsae) { + throw ExceptionFactory.createException(SSLParamsException.class, "Unsupported keystore algorithm [" + nsae.getMessage() + "]", nsae, + exceptionInterceptor); + } catch (KeyStoreException kse) { + throw ExceptionFactory.createException(SSLParamsException.class, "Could not create KeyStore instance [" + kse.getMessage() + "]", kse, + exceptionInterceptor); + } catch (CertificateException nsae) { + throw ExceptionFactory.createException(SSLParamsException.class, + "Could not load client" + clientCertificateKeyStoreType + " keystore from " + clientCertificateKeyStoreUrl, nsae, exceptionInterceptor); + } catch (MalformedURLException mue) { + throw ExceptionFactory.createException(SSLParamsException.class, clientCertificateKeyStoreUrl + " does not appear to be a valid URL.", mue, + exceptionInterceptor); + } catch (IOException ioe) { + throw ExceptionFactory.createException(SSLParamsException.class, "Cannot open " + clientCertificateKeyStoreUrl + " [" + ioe.getMessage() + "]", + ioe, exceptionInterceptor); + } finally { + if (ksIS != null) { + try { + ksIS.close(); + } catch (IOException e) { + // can't close input stream, but keystore can be properly initialized so we shouldn't throw this exception + } + } + } + } + + InputStream trustStoreIS = null; + try { + String trustStoreType = ""; + char[] trustStorePassword = null; + KeyStore trustKeyStore = null; + + if (!StringUtils.isNullOrEmpty(trustCertificateKeyStoreUrl) && !StringUtils.isNullOrEmpty(trustCertificateKeyStoreType)) { + trustStoreType = trustCertificateKeyStoreType; + trustStorePassword = (trustCertificateKeyStorePassword == null) ? new char[0] : trustCertificateKeyStorePassword.toCharArray(); + trustStoreIS = new URL(trustCertificateKeyStoreUrl).openStream(); + + trustKeyStore = KeyStore.getInstance(trustStoreType); + trustKeyStore.load(trustStoreIS, trustStorePassword); + } + + if (trustKeyStore != null || verifyServerCert && fallbackToDefaultTrustStore) { + tmf.init(trustKeyStore); // (trustKeyStore == null) initializes the TrustManagerFactory with the default truststore. + + // building the customized list of TrustManagers from original one if it's available + TrustManager[] origTms = tmf.getTrustManagers(); + + for (TrustManager tm : origTms) { + // wrap X509TrustManager or put original if non-X509 TrustManager + tms.add(tm instanceof X509TrustManager ? new X509TrustManagerWrapper((X509TrustManager) tm, verifyServerCert, hostName) : tm); + } + } + } catch (MalformedURLException e) { + throw ExceptionFactory.createException(SSLParamsException.class, trustCertificateKeyStoreUrl + " does not appear to be a valid URL.", e, + exceptionInterceptor); + } catch (NoSuchAlgorithmException e) { + throw ExceptionFactory.createException(SSLParamsException.class, "Unsupported keystore algorithm [" + e.getMessage() + "]", e, + exceptionInterceptor); + } catch (KeyStoreException e) { + throw ExceptionFactory.createException(SSLParamsException.class, "Could not create KeyStore instance [" + e.getMessage() + "]", e, + exceptionInterceptor); + } catch (CertificateException e) { + throw ExceptionFactory.createException(SSLParamsException.class, + "Could not load trust" + trustCertificateKeyStoreType + " keystore from " + trustCertificateKeyStoreUrl, e, exceptionInterceptor); + } catch (IOException e) { + throw ExceptionFactory.createException(SSLParamsException.class, "Cannot open " + trustCertificateKeyStoreUrl + " [" + e.getMessage() + "]", e, + exceptionInterceptor); + } finally { + if (trustStoreIS != null) { + try { + trustStoreIS.close(); + } catch (IOException e) { + // can't close input stream, but keystore can be properly initialized so we shouldn't throw this exception + } + } + } + + // if original TrustManagers are not available then putting one X509TrustManagerWrapper which take care only about expiration check + if (tms.size() == 0) { + tms.add(new X509TrustManagerWrapper(verifyServerCert, hostName)); + } + + try { + SSLContext sslContext = SSLContext.getInstance("TLS"); + sslContext.init(kms, tms.toArray(new TrustManager[tms.size()]), null); + + return sslContext; + + } catch (NoSuchAlgorithmException nsae) { + throw new SSLParamsException("TLS is not a valid SSL protocol.", nsae); + } catch (KeyManagementException kme) { + throw new SSLParamsException("KeyManagementException: " + kme.getMessage(), kme); + } + } + + public static boolean isSSLEstablished(Socket socket) { + return socket == null ? false : SSLSocket.class.isAssignableFrom(socket.getClass()); + } + + public static RSAPublicKey decodeRSAPublicKey(String key) throws RSAException { + if (key == null) { + throw ExceptionFactory.createException(RSAException.class, "Key parameter is null"); + } + + int offset = key.indexOf("\n") + 1; + int len = key.indexOf("-----END PUBLIC KEY-----") - offset; + + // TODO: use standard decoders with Java 6+ + byte[] certificateData = Base64Decoder.decode(key.getBytes(), offset, len); + + X509EncodedKeySpec spec = new X509EncodedKeySpec(certificateData); + try { + KeyFactory kf = KeyFactory.getInstance("RSA"); + return (RSAPublicKey) kf.generatePublic(spec); + } catch (NoSuchAlgorithmException | InvalidKeySpecException e) { + throw ExceptionFactory.createException(RSAException.class, "Unable to decode public key", e); + } + } + + public static byte[] encryptWithRSAPublicKey(byte[] source, RSAPublicKey key, String transformation) throws RSAException { + try { + Cipher cipher = Cipher.getInstance(transformation); + cipher.init(Cipher.ENCRYPT_MODE, key); + return cipher.doFinal(source); + } catch (NoSuchAlgorithmException | NoSuchPaddingException | InvalidKeyException | IllegalBlockSizeException | BadPaddingException e) { + throw ExceptionFactory.createException(RSAException.class, e.getMessage(), e); + } + } + + public static byte[] encryptWithRSAPublicKey(byte[] source, RSAPublicKey key) throws RSAException { + return encryptWithRSAPublicKey(source, key, "RSA/ECB/OAEPWithSHA-1AndMGF1Padding"); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/NamedPipeSocketFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/NamedPipeSocketFactory.java new file mode 100644 index 0000000..1c5f077 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/NamedPipeSocketFactory.java @@ -0,0 +1,273 @@ +/* + * Copyright (c) 2002, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.io.Closeable; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.io.RandomAccessFile; +import java.net.Socket; +import java.net.SocketException; +import java.util.concurrent.TimeUnit; + +import com.mysql.cj.Messages; +import com.mysql.cj.Session; +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.conf.RuntimeProperty; +import com.mysql.cj.log.Log; + +/** + * A socket factory for named pipes (on Windows) + */ +public class NamedPipeSocketFactory implements SocketFactory { + private static final int DEFAULT_TIMEOUT = 100; + + /** + * A socket that encapsulates named pipes on Windows + */ + class NamedPipeSocket extends Socket { + private boolean isClosed = false; + + private RandomAccessFile namedPipeFile; + + NamedPipeSocket(String filePath, int timeout) throws IOException { + if ((filePath == null) || (filePath.length() == 0)) { + throw new IOException(Messages.getString("NamedPipeSocketFactory.4")); + } + + int timeoutCountdown = timeout == 0 ? DEFAULT_TIMEOUT : timeout; + long startTime = System.currentTimeMillis(); + for (;;) { + try { + this.namedPipeFile = new RandomAccessFile(filePath, "rw"); + break; + } catch (FileNotFoundException e) { + if (timeout == 0) { // No timeout was set. + throw new IOException("Named pipe busy error (ERROR_PIPE_BUSY).\nConsider setting a value for " + + "'connectTimeout' or DriverManager.setLoginTimeout(int) to repeatedly try opening the named pipe before failing.", e); + } + if (System.currentTimeMillis() - startTime > timeoutCountdown) { + throw e; + } + } + try { + TimeUnit.MILLISECONDS.sleep(10); + } catch (InterruptedException e) { + throw new IOException(e); + } + } + } + + /** + * @see java.net.Socket#close() + */ + @Override + public synchronized void close() throws IOException { + this.namedPipeFile.close(); + this.isClosed = true; + } + + /** + * @see java.net.Socket#getInputStream() + */ + @Override + public InputStream getInputStream() throws IOException { + return new RandomAccessFileInputStream(this.namedPipeFile); + } + + /** + * @see java.net.Socket#getOutputStream() + */ + @Override + public OutputStream getOutputStream() throws IOException { + return new RandomAccessFileOutputStream(this.namedPipeFile); + } + + /** + * @see java.net.Socket#isClosed() + */ + @Override + public boolean isClosed() { + return this.isClosed; + } + + @Override + public void shutdownInput() throws IOException { + // no-op + } + } + + /** + * Enables OutputStream-type functionality for a RandomAccessFile + */ + class RandomAccessFileInputStream extends InputStream { + RandomAccessFile raFile; + + RandomAccessFileInputStream(RandomAccessFile file) { + this.raFile = file; + } + + /** + * @see java.io.InputStream#available() + */ + @Override + public int available() throws IOException { + return -1; + } + + /** + * @see java.io.InputStream#close() + */ + @Override + public void close() throws IOException { + this.raFile.close(); + } + + /** + * @see java.io.InputStream#read() + */ + @Override + public int read() throws IOException { + return this.raFile.read(); + } + + /** + * @see java.io.InputStream#read(byte[]) + */ + @Override + public int read(byte[] b) throws IOException { + return this.raFile.read(b); + } + + /** + * @see java.io.InputStream#read(byte[], int, int) + */ + @Override + public int read(byte[] b, int off, int len) throws IOException { + return this.raFile.read(b, off, len); + } + } + + /** + * Enables OutputStream-type functionality for a RandomAccessFile + */ + class RandomAccessFileOutputStream extends OutputStream { + RandomAccessFile raFile; + + RandomAccessFileOutputStream(RandomAccessFile file) { + this.raFile = file; + } + + /** + * @see java.io.OutputStream#close() + */ + @Override + public void close() throws IOException { + this.raFile.close(); + } + + /** + * @see java.io.OutputStream#write(byte[]) + */ + @Override + public void write(byte[] b) throws IOException { + this.raFile.write(b); + } + + /** + * @see java.io.OutputStream#write(byte[], int, int) + */ + @Override + public void write(byte[] b, int off, int len) throws IOException { + this.raFile.write(b, off, len); + } + + /** + * @see java.io.OutputStream#write(int) + */ + @Override + public void write(int b) throws IOException { + } + } + + private Socket namedPipeSocket; + + /** + * Constructor for NamedPipeSocketFactory. + */ + public NamedPipeSocketFactory() { + super(); + } + + @Override + public T performTlsHandshake(SocketConnection socketConnection, ServerSession serverSession) throws IOException { + return performTlsHandshake(socketConnection, serverSession, null); + } + + @SuppressWarnings("unchecked") + @Override + public T performTlsHandshake(SocketConnection socketConnection, ServerSession serverSession, Log log) throws IOException { + return (T) this.namedPipeSocket; + } + + @SuppressWarnings("unchecked") + @Override + public T connect(String host, int portNumber /* ignored */, PropertySet props, int loginTimeout) throws IOException { + String namedPipePath = null; + + RuntimeProperty path = props.getStringProperty(PropertyKey.PATH); + if (path != null) { + namedPipePath = path.getValue(); + } + + if (namedPipePath == null) { + namedPipePath = "\\\\.\\pipe\\MySQL"; + } else if (namedPipePath.length() == 0) { + throw new SocketException( + Messages.getString("NamedPipeSocketFactory.2") + PropertyKey.PATH.getCcAlias() + Messages.getString("NamedPipeSocketFactory.3")); + } + + int connectTimeout = props.getIntegerProperty(PropertyKey.connectTimeout.getKeyName()).getValue(); + int timeout = (connectTimeout > 0 && loginTimeout > 0) ? Math.min(connectTimeout, loginTimeout) : connectTimeout + loginTimeout; + + this.namedPipeSocket = new NamedPipeSocket(namedPipePath, timeout); + + return (T) this.namedPipeSocket; + } + + @Override + public boolean isLocallyConnected(Session sess) { + // Until I learn otherwise (or learn how to detect it), I assume that we are + return true; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/ReadAheadInputStream.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/ReadAheadInputStream.java new file mode 100644 index 0000000..4c939f6 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/ReadAheadInputStream.java @@ -0,0 +1,286 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.io.IOException; +import java.io.InputStream; +import java.util.Arrays; + +import com.mysql.cj.log.Log; + +/** + * A non-blocking buffered input stream. Reads more if it can, won't block to fill the buffer, only blocks to satisfy a request of read(byte[]) + */ +public class ReadAheadInputStream extends InputStream { + + private final static int DEFAULT_BUFFER_SIZE = 4096; + + private InputStream underlyingStream; + + private byte buf[]; + + protected int endOfCurrentData; + + protected int currentPosition; + + protected boolean doDebug = false; + + protected Log log; + + private void fill(int readAtLeastTheseManyBytes) throws IOException { + checkClosed(); + + this.currentPosition = 0; /* no mark: throw away the buffer */ + + this.endOfCurrentData = this.currentPosition; + + // Read at least as many bytes as the caller wants, but don't block to fill the whole buffer (like java.io.BufferdInputStream does) + + int bytesToRead = Math.min(this.buf.length - this.currentPosition, readAtLeastTheseManyBytes); + + int bytesAvailable = this.underlyingStream.available(); + + if (bytesAvailable > bytesToRead) { + + // Great, there's more available, let's grab those bytes too! (read-ahead) + + bytesToRead = Math.min(this.buf.length - this.currentPosition, bytesAvailable); + } + + if (this.doDebug) { + StringBuilder debugBuf = new StringBuilder(); + debugBuf.append(" ReadAheadInputStream.fill("); + debugBuf.append(readAtLeastTheseManyBytes); + debugBuf.append("), buffer_size="); + debugBuf.append(this.buf.length); + debugBuf.append(", current_position="); + debugBuf.append(this.currentPosition); + debugBuf.append(", need to read "); + debugBuf.append(Math.min(this.buf.length - this.currentPosition, readAtLeastTheseManyBytes)); + debugBuf.append(" bytes to fill request,"); + + if (bytesAvailable > 0) { + debugBuf.append(" underlying InputStream reports "); + debugBuf.append(bytesAvailable); + + debugBuf.append(" total bytes available,"); + } + + debugBuf.append(" attempting to read "); + debugBuf.append(bytesToRead); + debugBuf.append(" bytes."); + + if (this.log != null) { + this.log.logTrace(debugBuf.toString()); + } else { + System.err.println(debugBuf.toString()); + } + } + + int n = this.underlyingStream.read(this.buf, this.currentPosition, bytesToRead); + + if (n > 0) { + this.endOfCurrentData = n + this.currentPosition; + } + } + + private int readFromUnderlyingStreamIfNecessary(byte[] b, int off, int len) throws IOException { + checkClosed(); + + int avail = this.endOfCurrentData - this.currentPosition; + + if (this.doDebug) { + StringBuilder debugBuf = new StringBuilder(); + debugBuf.append("ReadAheadInputStream.readIfNecessary("); + debugBuf.append(Arrays.toString(b)); + debugBuf.append(","); + debugBuf.append(off); + debugBuf.append(","); + debugBuf.append(len); + debugBuf.append(")"); + + if (avail <= 0) { + debugBuf.append(" not all data available in buffer, must read from stream"); + + if (len >= this.buf.length) { + debugBuf.append(", amount requested > buffer, returning direct read() from stream"); + } + } + + if (this.log != null) { + this.log.logTrace(debugBuf.toString()); + } else { + System.err.println(debugBuf.toString()); + } + } + + if (avail <= 0) { + + if (len >= this.buf.length) { + return this.underlyingStream.read(b, off, len); + } + + fill(len); + + avail = this.endOfCurrentData - this.currentPosition; + + if (avail <= 0) { + return -1; + } + } + + int bytesActuallyRead = (avail < len) ? avail : len; + + System.arraycopy(this.buf, this.currentPosition, b, off, bytesActuallyRead); + + this.currentPosition += bytesActuallyRead; + + return bytesActuallyRead; + } + + @Override + public synchronized int read(byte b[], int off, int len) throws IOException { + checkClosed(); // Check for closed stream + if ((off | len | (off + len) | (b.length - (off + len))) < 0) { + throw new IndexOutOfBoundsException(); + } else if (len == 0) { + return 0; + } + + int totalBytesRead = 0; + + while (true) { + int bytesReadThisRound = readFromUnderlyingStreamIfNecessary(b, off + totalBytesRead, len - totalBytesRead); + + // end-of-stream? + if (bytesReadThisRound <= 0) { + if (totalBytesRead == 0) { + totalBytesRead = bytesReadThisRound; + } + + break; + } + + totalBytesRead += bytesReadThisRound; + + // Read _at_least_ enough bytes + if (totalBytesRead >= len) { + break; + } + + // Nothing to read? + if (this.underlyingStream.available() <= 0) { + break; + } + } + + return totalBytesRead; + } + + @Override + public int read() throws IOException { + checkClosed(); + + if (this.currentPosition >= this.endOfCurrentData) { + fill(1); + if (this.currentPosition >= this.endOfCurrentData) { + return -1; + } + } + + return this.buf[this.currentPosition++] & 0xff; + } + + @Override + public int available() throws IOException { + checkClosed(); + + return this.underlyingStream.available() + (this.endOfCurrentData - this.currentPosition); + } + + private void checkClosed() throws IOException { + + if (this.buf == null) { + throw new IOException("Stream closed"); + } + } + + public ReadAheadInputStream(InputStream toBuffer, boolean debug, Log logTo) { + this(toBuffer, DEFAULT_BUFFER_SIZE, debug, logTo); + } + + public ReadAheadInputStream(InputStream toBuffer, int bufferSize, boolean debug, Log logTo) { + this.underlyingStream = toBuffer; + this.buf = new byte[bufferSize]; + this.doDebug = debug; + this.log = logTo; + } + + @Override + public void close() throws IOException { + if (this.underlyingStream != null) { + try { + this.underlyingStream.close(); + } finally { + this.underlyingStream = null; + this.buf = null; + this.log = null; + } + } + } + + @Override + public boolean markSupported() { + return false; + } + + @Override + public long skip(long n) throws IOException { + checkClosed(); + if (n <= 0) { + return 0; + } + + long bytesAvailInBuffer = this.endOfCurrentData - this.currentPosition; + + if (bytesAvailInBuffer <= 0) { + + fill((int) n); + bytesAvailInBuffer = this.endOfCurrentData - this.currentPosition; + if (bytesAvailInBuffer <= 0) { + return 0; + } + } + + long bytesSkipped = (bytesAvailInBuffer < n) ? bytesAvailInBuffer : n; + this.currentPosition += bytesSkipped; + return bytesSkipped; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/Security.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/Security.java new file mode 100644 index 0000000..61f6bd2 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/Security.java @@ -0,0 +1,188 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.security.DigestException; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; + +import com.mysql.cj.exceptions.AssertionFailedException; +import com.mysql.cj.util.StringUtils; + +/** + * Methods for doing secure authentication with MySQL-4.1 and newer. + */ +public class Security { + + private static int CACHING_SHA2_DIGEST_LENGTH = 32; + + /** + * Encrypt/Decrypt function used for password encryption in authentication + * + * Simple XOR is used here but it is OK as we encrypt random strings + * + * @param from + * IN Data for encryption + * @param to + * OUT Encrypt data to the buffer (may be the same) + * @param scramble + * IN Scramble used for encryption + * @param length + * IN Length of data to encrypt + */ + public static void xorString(byte[] from, byte[] to, byte[] scramble, int length) { + int pos = 0; + int scrambleLength = scramble.length; + + while (pos < length) { + to[pos] = (byte) (from[pos] ^ scramble[pos % scrambleLength]); + pos++; + } + } + + public static byte[] scramble411(String password, byte[] seed, String passwordEncoding) { + byte[] passwordBytes = (passwordEncoding == null || passwordEncoding.length() == 0) ? StringUtils.getBytes(password) + : StringUtils.getBytes(password, passwordEncoding); + return scramble411(passwordBytes, seed); + } + + /** + * Hashing for MySQL-4.1 authentication. Algorithm is as follows (c.f. sql/auth/password.c): + * + * 

+     * SERVER: public_seed=create_random_string()
+     * send(public_seed)
+     *
+     * CLIENT: recv(public_seed)
+     * hash_stage1=sha1("password")
+     * hash_stage2=sha1(hash_stage1)
+     * reply=xor(hash_stage1, sha1(public_seed,hash_stage2))
+     * send(reply)
+     *
+ * + * @param password + * password + * @param seed + * seed + * @return bytes + */ + public static byte[] scramble411(byte[] password, byte[] seed) { + MessageDigest md; + try { + md = MessageDigest.getInstance("SHA-1"); + } catch (NoSuchAlgorithmException ex) { + throw new AssertionFailedException(ex); + } + + byte[] passwordHashStage1 = md.digest(password); + md.reset(); + + byte[] passwordHashStage2 = md.digest(passwordHashStage1); + md.reset(); + + md.update(seed); + md.update(passwordHashStage2); + + byte[] toBeXord = md.digest(); + + int numToXor = toBeXord.length; + + for (int i = 0; i < numToXor; i++) { + toBeXord[i] = (byte) (toBeXord[i] ^ passwordHashStage1[i]); + } + + return toBeXord; + } + + /** + * Scrambling for caching_sha2_password plugin. + * + * 
+     * Scramble = XOR(SHA2(password), SHA2(SHA2(SHA2(password)), Nonce))
+     *
+ * + * @param password + * password + * @param seed + * seed + * @return bytes + * + * @throws DigestException + * if an error occurs + */ + public static byte[] scrambleCachingSha2(byte[] password, byte[] seed) throws DigestException { + /* + * Server does it in 4 steps (see sql/auth/sha2_password_common.cc Generate_scramble::scramble method): + * + * SHA2(src) => digest_stage1 + * SHA2(digest_stage1) => digest_stage2 + * SHA2(digest_stage2, m_rnd) => scramble_stage1 + * XOR(digest_stage1, scramble_stage1) => scramble + */ + MessageDigest md; + try { + md = MessageDigest.getInstance("SHA-256"); + } catch (NoSuchAlgorithmException ex) { + throw new AssertionFailedException(ex); + } + + byte[] dig1 = new byte[CACHING_SHA2_DIGEST_LENGTH]; + byte[] dig2 = new byte[CACHING_SHA2_DIGEST_LENGTH]; + byte[] scramble1 = new byte[CACHING_SHA2_DIGEST_LENGTH]; + + // SHA2(src) => digest_stage1 + md.update(password, 0, password.length); + md.digest(dig1, 0, CACHING_SHA2_DIGEST_LENGTH); + md.reset(); + + // SHA2(digest_stage1) => digest_stage2 + md.update(dig1, 0, dig1.length); + md.digest(dig2, 0, CACHING_SHA2_DIGEST_LENGTH); + md.reset(); + + // SHA2(digest_stage2, m_rnd) => scramble_stage1 + md.update(dig2, 0, dig1.length); + md.update(seed, 0, seed.length); + md.digest(scramble1, 0, CACHING_SHA2_DIGEST_LENGTH); + + // XOR(digest_stage1, scramble_stage1) => scramble + byte[] mysqlScrambleBuff = new byte[CACHING_SHA2_DIGEST_LENGTH]; + xorString(dig1, mysqlScrambleBuff, scramble1, CACHING_SHA2_DIGEST_LENGTH); + + return mysqlScrambleBuff; + } + + /** + * Prevent construction. + */ + private Security() { + super(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/SocksProxySocketFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/SocksProxySocketFactory.java new file mode 100644 index 0000000..46b4582 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/SocksProxySocketFactory.java @@ -0,0 +1,50 @@ +/* + * Copyright (c) 2014, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.net.InetSocketAddress; +import java.net.Proxy; +import java.net.Socket; + +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.conf.PropertySet; + +/** + * A socket factory used to create sockets connecting through a SOCKS proxy. The socket still supports all the same TCP features as the "standard" socket. + */ +public class SocksProxySocketFactory extends StandardSocketFactory { + + @Override + protected Socket createSocket(PropertySet props) { + String socksProxyHost = props.getStringProperty(PropertyKey.socksProxyHost).getValue(); + int socksProxyPort = props.getIntegerProperty(PropertyKey.socksProxyPort).getValue(); + return new Socket(new Proxy(Proxy.Type.SOCKS, new InetSocketAddress(socksProxyHost, socksProxyPort))); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/StandardSocketFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/StandardSocketFactory.java new file mode 100644 index 0000000..38a77ad --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/StandardSocketFactory.java @@ -0,0 +1,234 @@ +/* + * Copyright (c) 2002, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.io.Closeable; +import java.io.IOException; +import java.net.InetAddress; +import java.net.InetSocketAddress; +import java.net.Socket; +import java.net.SocketException; + +import com.mysql.cj.Messages; +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.log.Log; + +/** + * Socket factory for vanilla TCP/IP sockets (the standard) + */ +public class StandardSocketFactory implements SocketFactory { + + /** The hostname to connect to */ + protected String host = null; + + /** The port number to connect to */ + protected int port = 3306; + + /** The underlying TCP/IP socket to use */ + protected Socket rawSocket = null; + + /** The wrapper for underlying TCP/IP socket */ + protected Socket sslSocket = null; + + /** The remaining login time in milliseconds. Initial value set from defined DriverManager.setLoginTimeout() */ + protected int loginTimeoutCountdown = 0; + + /** Time when last Login Timeout check occurred */ + protected long loginTimeoutCheckTimestamp = System.currentTimeMillis(); + + /** Backup original Socket timeout to be restored after handshake */ + protected int socketTimeoutBackup = 0; + + /** + * Create the raw socket. + * + * @param props + * properties available to affect behaviour during socket creation. + * @return socket + */ + protected Socket createSocket(PropertySet props) { + return new Socket(); + } + + /** + * Configures socket properties based on properties from the connection + * (tcpNoDelay, snd/rcv buf, traffic class, etc). + * + * @param sock + * socket + * @param pset + * properties + * @throws SocketException + * if an error occurs + * @throws IOException + * if an error occurs + */ + private void configureSocket(Socket sock, PropertySet pset) throws SocketException, IOException { + sock.setTcpNoDelay(pset.getBooleanProperty(PropertyKey.tcpNoDelay).getValue()); + sock.setKeepAlive(pset.getBooleanProperty(PropertyKey.tcpKeepAlive).getValue()); + + int receiveBufferSize = pset.getIntegerProperty(PropertyKey.tcpRcvBuf).getValue(); + if (receiveBufferSize > 0) { + sock.setReceiveBufferSize(receiveBufferSize); + } + + int sendBufferSize = pset.getIntegerProperty(PropertyKey.tcpSndBuf).getValue(); + if (sendBufferSize > 0) { + sock.setSendBufferSize(sendBufferSize); + } + + int trafficClass = pset.getIntegerProperty(PropertyKey.tcpTrafficClass).getValue(); + if (trafficClass > 0) { + sock.setTrafficClass(trafficClass); + } + } + + @SuppressWarnings("unchecked") + public T connect(String hostname, int portNumber, PropertySet pset, int loginTimeout) throws IOException { + + this.loginTimeoutCountdown = loginTimeout; + + if (pset != null) { + this.host = hostname; + + this.port = portNumber; + + String localSocketHostname = pset.getStringProperty(PropertyKey.localSocketAddress).getValue(); + InetSocketAddress localSockAddr = null; + if (localSocketHostname != null && localSocketHostname.length() > 0) { + localSockAddr = new InetSocketAddress(InetAddress.getByName(localSocketHostname), 0); + } + + int connectTimeout = pset.getIntegerProperty(PropertyKey.connectTimeout).getValue(); + + if (this.host != null) { + InetAddress[] possibleAddresses = InetAddress.getAllByName(this.host); + + if (possibleAddresses.length == 0) { + throw new SocketException("No addresses for host"); + } + + // save last exception to propagate to caller if connection fails + SocketException lastException = null; + + // Need to loop through all possible addresses. Name lookup may return multiple addresses including IPv4 and IPv6 addresses. Some versions of + // MySQL don't listen on the IPv6 address so we try all addresses. + for (int i = 0; i < possibleAddresses.length; i++) { + try { + this.rawSocket = createSocket(pset); + + configureSocket(this.rawSocket, pset); + + InetSocketAddress sockAddr = new InetSocketAddress(possibleAddresses[i], this.port); + // bind to the local port if not using the ephemeral port + if (localSockAddr != null) { + this.rawSocket.bind(localSockAddr); + } + + this.rawSocket.connect(sockAddr, getRealTimeout(connectTimeout)); + + break; + } catch (SocketException ex) { + lastException = ex; + resetLoginTimeCountdown(); + this.rawSocket = null; + } + } + + if (this.rawSocket == null && lastException != null) { + throw lastException; + } + + resetLoginTimeCountdown(); + + this.sslSocket = this.rawSocket; + return (T) this.rawSocket; + } + } + + throw new SocketException("Unable to create socket"); + } + + public void beforeHandshake() throws IOException { + resetLoginTimeCountdown(); + this.socketTimeoutBackup = this.rawSocket.getSoTimeout(); + this.rawSocket.setSoTimeout(getRealTimeout(this.socketTimeoutBackup)); + } + + @Override + public T performTlsHandshake(SocketConnection socketConnection, ServerSession serverSession) throws IOException { + return performTlsHandshake(socketConnection, serverSession, null); + } + + @SuppressWarnings("unchecked") + @Override + public T performTlsHandshake(SocketConnection socketConnection, ServerSession serverSession, Log log) throws IOException { + this.sslSocket = ExportControlled.performTlsHandshake(this.rawSocket, socketConnection, serverSession == null ? null : serverSession.getServerVersion(), + log); + return (T) this.sslSocket; + } + + public void afterHandshake() throws IOException { + resetLoginTimeCountdown(); + this.rawSocket.setSoTimeout(this.socketTimeoutBackup); + } + + /** + * Decrements elapsed time since last reset from login timeout count down. + * + * @throws SocketException + * If the login timeout is reached or exceeded. + */ + protected void resetLoginTimeCountdown() throws SocketException { + if (this.loginTimeoutCountdown > 0) { + long now = System.currentTimeMillis(); + this.loginTimeoutCountdown -= now - this.loginTimeoutCheckTimestamp; + if (this.loginTimeoutCountdown <= 0) { + throw new SocketException(Messages.getString("Connection.LoginTimeout")); + } + this.loginTimeoutCheckTimestamp = now; + } + } + + /** + * Validates the connection/socket timeout that must really be used. + * + * @param expectedTimeout + * The timeout to validate. + * @return The timeout to be used. + */ + protected int getRealTimeout(int expectedTimeout) { + if (this.loginTimeoutCountdown > 0 && (expectedTimeout == 0 || expectedTimeout > this.loginTimeoutCountdown)) { + return this.loginTimeoutCountdown; + } + return expectedTimeout; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/WatchableOutputStream.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/WatchableOutputStream.java new file mode 100644 index 0000000..44bf1fd --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/WatchableOutputStream.java @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; + +/** + * A java.io.OutputStream used to write ASCII data into Blobs and Clobs + */ +public class WatchableOutputStream extends ByteArrayOutputStream implements WatchableStream { + private OutputStreamWatcher watcher; + + /** + * @see java.io.OutputStream#close() + */ + @Override + public void close() throws IOException { + super.close(); + + if (this.watcher != null) { + this.watcher.streamClosed(this); + } + } + + public void setWatcher(OutputStreamWatcher watcher) { + this.watcher = watcher; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/WatchableWriter.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/WatchableWriter.java new file mode 100644 index 0000000..7eb4cfe --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/WatchableWriter.java @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +import java.io.CharArrayWriter; + +/** + * A java.io.Writer used to write unicode data into Blobs and Clobs + */ +public class WatchableWriter extends CharArrayWriter { + private WriterWatcher watcher; + + /** + * @see java.io.Writer#close() + */ + @Override + public void close() { + super.close(); + + // Send data to watcher + if (this.watcher != null) { + this.watcher.writerClosed(this); + } + } + + /** + * @param watcher + * {@link WriterWatcher} + */ + public void setWatcher(WriterWatcher watcher) { + this.watcher = watcher; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/WriterWatcher.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/WriterWatcher.java new file mode 100644 index 0000000..0aeac95 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/WriterWatcher.java @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2002, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol; + +/** + * Objects that want to be notified of lifecycle events on a WatchableWriter should implement this interface, and register themselves with setWatcher() on the + * WatchableWriter instance. + */ +public interface WriterWatcher { + /** + * Called when the Writer being watched has .close() called + * + * @param out + * WatchableWriter instance + */ + void writerClosed(WatchableWriter out); +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/result/AbstractResultsetRow.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/result/AbstractResultsetRow.java new file mode 100644 index 0000000..13aab0f --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/protocol/result/AbstractResultsetRow.java @@ -0,0 +1,258 @@ +/* + * Copyright (c) 2007, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.protocol.result; + +import com.mysql.cj.Messages; +import com.mysql.cj.MysqlType; +import com.mysql.cj.exceptions.DataReadException; +import com.mysql.cj.exceptions.ExceptionInterceptor; +import com.mysql.cj.protocol.ColumnDefinition; +import com.mysql.cj.protocol.ResultsetRow; +import com.mysql.cj.protocol.ValueDecoder; +import com.mysql.cj.result.Field; +import com.mysql.cj.result.Row; +import com.mysql.cj.result.ValueFactory; + +public abstract class AbstractResultsetRow implements ResultsetRow { + protected ExceptionInterceptor exceptionInterceptor; + + protected AbstractResultsetRow(ExceptionInterceptor exceptionInterceptor) { + this.exceptionInterceptor = exceptionInterceptor; + } + + /** + * The metadata of the fields of this result set. + */ + protected ColumnDefinition metadata; + + protected ValueDecoder valueDecoder; + + /** Did the previous value retrieval find a NULL? */ + protected boolean wasNull; + + /** + * Decode the wire-level result bytes and call the value factory. + * + * @param columnIndex + * column index + * @param bytes + * bytes array with result data + * @param offset + * offset in array + * @param length + * data length + * @param vf + * {@link ValueFactory} + * @param + * value type + * @return value + */ + private T decodeAndCreateReturnValue(int columnIndex, byte[] bytes, int offset, int length, ValueFactory vf) { + Field f = this.metadata.getFields()[columnIndex]; + + // First, figure out which decoder method to call basing on the protocol value type from metadata; + // it's the best way to find the appropriate decoder, we can't rely completely on MysqlType here + // because the same MysqlType can be represented by different protocol types and also DatabaseMetaData methods, + // eg. buildResultSet(), could imply unexpected conversions when substitutes RowData in ResultSet; + switch (f.getMysqlTypeId()) { + case MysqlType.FIELD_TYPE_DATETIME: + return this.valueDecoder.decodeDatetime(bytes, offset, length, f.getDecimals(), vf); + + case MysqlType.FIELD_TYPE_TIMESTAMP: + return this.valueDecoder.decodeTimestamp(bytes, offset, length, f.getDecimals(), vf); + + case MysqlType.FIELD_TYPE_DATE: + return this.valueDecoder.decodeDate(bytes, offset, length, vf); + + case MysqlType.FIELD_TYPE_TIME: + return this.valueDecoder.decodeTime(bytes, offset, length, f.getDecimals(), vf); + + case MysqlType.FIELD_TYPE_TINY: + return f.isUnsigned() ? this.valueDecoder.decodeUInt1(bytes, offset, length, vf) : this.valueDecoder.decodeInt1(bytes, offset, length, vf); + + case MysqlType.FIELD_TYPE_YEAR: + return this.valueDecoder.decodeYear(bytes, offset, length, vf); + + case MysqlType.FIELD_TYPE_SHORT: + return f.isUnsigned() ? this.valueDecoder.decodeUInt2(bytes, offset, length, vf) : this.valueDecoder.decodeInt2(bytes, offset, length, vf); + + case MysqlType.FIELD_TYPE_LONG: + return f.isUnsigned() ? this.valueDecoder.decodeUInt4(bytes, offset, length, vf) : this.valueDecoder.decodeInt4(bytes, offset, length, vf); + + case MysqlType.FIELD_TYPE_INT24: + return this.valueDecoder.decodeInt4(bytes, offset, length, vf); + + case MysqlType.FIELD_TYPE_LONGLONG: + return f.isUnsigned() ? this.valueDecoder.decodeUInt8(bytes, offset, length, vf) : this.valueDecoder.decodeInt8(bytes, offset, length, vf); + + case MysqlType.FIELD_TYPE_FLOAT: + return this.valueDecoder.decodeFloat(bytes, offset, length, vf); + + case MysqlType.FIELD_TYPE_DOUBLE: + return this.valueDecoder.decodeDouble(bytes, offset, length, vf); + + case MysqlType.FIELD_TYPE_NEWDECIMAL: + case MysqlType.FIELD_TYPE_DECIMAL: + return this.valueDecoder.decodeDecimal(bytes, offset, length, vf); + + case MysqlType.FIELD_TYPE_VAR_STRING: + case MysqlType.FIELD_TYPE_VARCHAR: + case MysqlType.FIELD_TYPE_STRING: + case MysqlType.FIELD_TYPE_TINY_BLOB: + case MysqlType.FIELD_TYPE_MEDIUM_BLOB: + case MysqlType.FIELD_TYPE_LONG_BLOB: + case MysqlType.FIELD_TYPE_BLOB: + case MysqlType.FIELD_TYPE_ENUM: + case MysqlType.FIELD_TYPE_GEOMETRY: + case MysqlType.FIELD_TYPE_JSON: + return this.valueDecoder.decodeByteArray(bytes, offset, length, f, vf); + + case MysqlType.FIELD_TYPE_SET: + return this.valueDecoder.decodeSet(bytes, offset, length, f, vf); + + case MysqlType.FIELD_TYPE_BIT: + return this.valueDecoder.decodeBit(bytes, offset, length, vf); + + case MysqlType.FIELD_TYPE_NULL: + return vf.createFromNull(); + } + + // If the protocol type isn't available then select decoder basing on MysqlType; that's for some internal + // code that creates rows without MySQL protocol types, only MysqlType types, including PS bindings as RS, DBMD + switch (f.getMysqlType()) { + case TINYINT: + return this.valueDecoder.decodeInt1(bytes, offset, length, vf); + case TINYINT_UNSIGNED: + return this.valueDecoder.decodeUInt1(bytes, offset, length, vf); + case SMALLINT: + return this.valueDecoder.decodeInt2(bytes, offset, length, vf); + case YEAR: + return this.valueDecoder.decodeYear(bytes, offset, length, vf); + case SMALLINT_UNSIGNED: + return this.valueDecoder.decodeUInt2(bytes, offset, length, vf); + case INT: + case MEDIUMINT: + return this.valueDecoder.decodeInt4(bytes, offset, length, vf); + case INT_UNSIGNED: + case MEDIUMINT_UNSIGNED: + return this.valueDecoder.decodeUInt4(bytes, offset, length, vf); + case BIGINT: + return this.valueDecoder.decodeInt8(bytes, offset, length, vf); + case BIGINT_UNSIGNED: + return this.valueDecoder.decodeUInt8(bytes, offset, length, vf); + case FLOAT: + case FLOAT_UNSIGNED: + return this.valueDecoder.decodeFloat(bytes, offset, length, vf); + case DOUBLE: + case DOUBLE_UNSIGNED: + return this.valueDecoder.decodeDouble(bytes, offset, length, vf); + case DECIMAL: + case DECIMAL_UNSIGNED: + return this.valueDecoder.decodeDecimal(bytes, offset, length, vf); + + case BOOLEAN: + case VARBINARY: + case VARCHAR: + case BINARY: + case CHAR: + case TINYBLOB: + case BLOB: + case MEDIUMBLOB: + case LONGBLOB: + case TINYTEXT: + case TEXT: + case MEDIUMTEXT: + case LONGTEXT: + case JSON: + case ENUM: + case SET: + case GEOMETRY: + case UNKNOWN: + return this.valueDecoder.decodeByteArray(bytes, offset, length, f, vf); + + case BIT: + return this.valueDecoder.decodeBit(bytes, offset, length, vf); + + case DATETIME: + case TIMESTAMP: + return this.valueDecoder.decodeTimestamp(bytes, offset, length, f.getDecimals(), vf); + case DATE: + return this.valueDecoder.decodeDate(bytes, offset, length, vf); + case TIME: + return this.valueDecoder.decodeTime(bytes, offset, length, f.getDecimals(), vf); + + case NULL: + return vf.createFromNull(); + + } + + throw new DataReadException(Messages.getString("ResultSet.UnknownSourceType")); + } + + /** + * Get a value from a byte array. The byte array is interpreted by the {@link com.mysql.cj.protocol.ValueDecoder} which uses the value factory create the + * return value. + * + * @param columnIndex + * The (internal) index of the column + * @param bytes + * byte array + * @param offset + * offset into byte array + * @param length + * length of value in byte array + * @param vf + * value factory + * @param + * value type + * @return value + */ + protected T getValueFromBytes(int columnIndex, byte[] bytes, int offset, int length, ValueFactory vf) { + if (getNull(columnIndex)) { + return vf.createFromNull(); + } + + // value factory may return null for zeroDateTimeBehavior=CONVERT_TO_NULL so check the return value + T retVal = decodeAndCreateReturnValue(columnIndex, bytes, offset, length, vf); + this.wasNull = (retVal == null); + return retVal; + } + + @Override + public Row setMetadata(ColumnDefinition f) { + this.metadata = f; + + return this; + } + + public boolean wasNull() { + return this.wasNull; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/AbstractDateTimeValueFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/AbstractDateTimeValueFactory.java new file mode 100644 index 0000000..fa7a57a --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/AbstractDateTimeValueFactory.java @@ -0,0 +1,141 @@ +/* + * Copyright (c) 2019, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import com.mysql.cj.Messages; +import com.mysql.cj.conf.PropertyDefinitions; +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.DataConversionException; +import com.mysql.cj.protocol.InternalDate; +import com.mysql.cj.protocol.InternalTime; +import com.mysql.cj.protocol.InternalTimestamp; +import com.mysql.cj.protocol.a.MysqlTextValueDecoder; +import com.mysql.cj.util.StringUtils; + +public abstract class AbstractDateTimeValueFactory extends DefaultValueFactory { + + public AbstractDateTimeValueFactory(PropertySet pset) { + super(pset); + } + + abstract T localCreateFromDate(InternalDate idate); + + abstract T localCreateFromTime(InternalTime it); + + abstract T localCreateFromTimestamp(InternalTimestamp its); + + abstract T localCreateFromDatetime(InternalTimestamp its); + + @Override + public T createFromDate(InternalDate idate) { + if (idate.isZero()) { + switch (this.pset.getEnumProperty(PropertyKey.zeroDateTimeBehavior).getValue()) { + case CONVERT_TO_NULL: + return null; + case ROUND: + return localCreateFromDate(new InternalDate(1, 1, 1)); + default: + break; + } + } + return localCreateFromDate(idate); + } + + @Override + public T createFromTime(InternalTime it) { + return localCreateFromTime(it); + } + + @Override + public T createFromTimestamp(InternalTimestamp its) { + if (its.isZero()) { + switch (this.pset.getEnumProperty(PropertyKey.zeroDateTimeBehavior).getValue()) { + case CONVERT_TO_NULL: + return null; + case ROUND: + return localCreateFromTimestamp(new InternalTimestamp(1, 1, 1, 0, 0, 0, 0, 0)); + default: + break; + } + } + return localCreateFromTimestamp(its); + } + + @Override + public T createFromDatetime(InternalTimestamp its) { + if (its.isZero()) { + switch (this.pset.getEnumProperty(PropertyKey.zeroDateTimeBehavior).getValue()) { + case CONVERT_TO_NULL: + return null; + case ROUND: + return localCreateFromDatetime(new InternalTimestamp(1, 1, 1, 0, 0, 0, 0, 0)); + default: + break; + } + } + return localCreateFromDatetime(its); + } + + @Override + public T createFromYear(long year) { + if (this.pset.getBooleanProperty(PropertyKey.yearIsDateType).getValue()) { + if (year < 100) { + if (year <= 69) { + year += 100; + } + year += 1900; + } + return createFromDate(new InternalDate((int) year, 1, 1)); + } + return createFromLong(year); + } + + @Override + public T createFromBytes(byte[] bytes, int offset, int length, Field f) { + if (length == 0 && this.pset.getBooleanProperty(PropertyKey.emptyStringsConvertToZero).getValue()) { + return createFromLong(0); + } + + String s = StringUtils.toString(bytes, offset, length, f.getEncoding()); + byte[] newBytes = s.getBytes(); + + if (MysqlTextValueDecoder.isDate(s)) { + return createFromDate(MysqlTextValueDecoder.getDate(newBytes, 0, newBytes.length)); + + } else if (MysqlTextValueDecoder.isTime(s)) { + return createFromTime(MysqlTextValueDecoder.getTime(newBytes, 0, newBytes.length, f.getDecimals())); + + } else if (MysqlTextValueDecoder.isTimestamp(s)) { + return createFromTimestamp(MysqlTextValueDecoder.getTimestamp(newBytes, 0, newBytes.length, f.getDecimals())); + } + throw new DataConversionException(Messages.getString("ResultSet.UnableToConvertString", new Object[] { s, getTargetTypeName() })); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/AbstractNumericValueFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/AbstractNumericValueFactory.java new file mode 100644 index 0000000..4391fa0 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/AbstractNumericValueFactory.java @@ -0,0 +1,72 @@ +/* + * Copyright (c) 2019, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import com.mysql.cj.Messages; +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.DataConversionException; +import com.mysql.cj.protocol.a.MysqlTextValueDecoder; +import com.mysql.cj.util.StringUtils; + +public abstract class AbstractNumericValueFactory extends DefaultValueFactory { + + public AbstractNumericValueFactory(PropertySet pset) { + super(pset); + } + + @Override + public T createFromBytes(byte[] bytes, int offset, int length, Field f) { + if (length == 0 && this.pset.getBooleanProperty(PropertyKey.emptyStringsConvertToZero).getValue()) { + return createFromLong(0); + } + + String s = StringUtils.toString(bytes, offset, length, f.getEncoding()); + byte[] newBytes = s.getBytes(); + + if (s.contains("e") || s.contains("E") || s.matches("-?\\d*\\.\\d*")) { + // floating point + return createFromDouble(MysqlTextValueDecoder.getDouble(newBytes, 0, newBytes.length)); + } else if (s.matches("-?\\d+")) { + // integer + if (s.charAt(0) == '-' // TODO shouldn't we check the length as well? + || length <= (MysqlTextValueDecoder.MAX_SIGNED_LONG_LEN - 1) && newBytes[0] >= '0' && newBytes[0] <= '8') { + return createFromLong(MysqlTextValueDecoder.getLong(newBytes, 0, newBytes.length)); + } + return createFromBigInteger(MysqlTextValueDecoder.getBigInteger(newBytes, 0, newBytes.length)); + } + throw new DataConversionException(Messages.getString("ResultSet.UnableToInterpretString", new Object[] { s })); + } + + @Override + public T createFromYear(long l) { + return createFromLong(l); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/BigDecimalValueFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/BigDecimalValueFactory.java new file mode 100644 index 0000000..9bbf066 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/BigDecimalValueFactory.java @@ -0,0 +1,103 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.nio.ByteBuffer; + +import com.mysql.cj.conf.PropertySet; + +/** + * A value factory for creating {@link java.math.BigDecimal} values. + */ +public class BigDecimalValueFactory extends AbstractNumericValueFactory { + int scale; + boolean hasScale; + + public BigDecimalValueFactory(PropertySet pset) { + super(pset); + } + + public BigDecimalValueFactory(PropertySet pset, int scale) { + super(pset); + this.scale = scale; + this.hasScale = true; + } + + /** + * Adjust the result value by apply the scale, if appropriate. + * + * @param d + * value + * @return result + */ + private BigDecimal adjustResult(BigDecimal d) { + if (this.hasScale) { + try { + return d.setScale(this.scale); + } catch (ArithmeticException ex) { + // try this if above fails + return d.setScale(this.scale, BigDecimal.ROUND_HALF_UP); + } + } + + return d; + } + + @Override + public BigDecimal createFromBigInteger(BigInteger i) { + return adjustResult(new BigDecimal(i)); + } + + @Override + public BigDecimal createFromLong(long l) { + return adjustResult(BigDecimal.valueOf(l)); + } + + @Override + public BigDecimal createFromBigDecimal(BigDecimal d) { + return adjustResult(d); + } + + @Override + public BigDecimal createFromDouble(double d) { + return adjustResult(BigDecimal.valueOf(d)); + } + + @Override + public BigDecimal createFromBit(byte[] bytes, int offset, int length) { + return new BigDecimal(new BigInteger(ByteBuffer.allocate(length + 1).put((byte) 0).put(bytes, offset, length).array())); + } + + public String getTargetTypeName() { + return BigDecimal.class.getName(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/BinaryStreamValueFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/BinaryStreamValueFactory.java new file mode 100644 index 0000000..1f1c7f5 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/BinaryStreamValueFactory.java @@ -0,0 +1,54 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.io.ByteArrayInputStream; +import java.io.InputStream; + +import com.mysql.cj.conf.PropertySet; + +/** + * A value factory for a raw stream of bytes from the value. + */ +public class BinaryStreamValueFactory extends DefaultValueFactory { + + public BinaryStreamValueFactory(PropertySet pset) { + super(pset); + } + + @Override + public InputStream createFromBytes(byte[] bytes, int offset, int length, Field f) { + return new ByteArrayInputStream(bytes, offset, length); + } + + public String getTargetTypeName() { + return InputStream.class.getName(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/BooleanValueFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/BooleanValueFactory.java new file mode 100644 index 0000000..e6e3b0c --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/BooleanValueFactory.java @@ -0,0 +1,117 @@ +/* + * Copyright (c) 2015, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.math.BigDecimal; +import java.math.BigInteger; + +import com.mysql.cj.Constants; +import com.mysql.cj.Messages; +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.DataConversionException; +import com.mysql.cj.protocol.a.MysqlTextValueDecoder; +import com.mysql.cj.util.DataTypeUtil; +import com.mysql.cj.util.StringUtils; + +/** + * A value factory for creating {@link java.lang.Boolean} values. + */ +public class BooleanValueFactory extends DefaultValueFactory { + + public BooleanValueFactory(PropertySet pset) { + super(pset); + } + + @Override + public Boolean createFromLong(long l) { + // Goes back to ODBC driver compatibility, and VB/Automation Languages/COM, where in Windows "-1" can mean true as well. + return (l == -1 || l > 0); + } + + @Override + public Boolean createFromBigInteger(BigInteger i) { + return i.compareTo(Constants.BIG_INTEGER_ZERO) > 0 || i.compareTo(Constants.BIG_INTEGER_NEGATIVE_ONE) == 0; + } + + @Override + // getBoolean() from DOUBLE, DECIMAL are required by JDBC spec.... + public Boolean createFromDouble(double d) { + // this means that 0.1 or -1 will be TRUE + return d > 0 || d == -1.0d; + } + + @Override + public Boolean createFromBigDecimal(BigDecimal d) { + // this means that 0.1 or -1 will be TRUE + return d.compareTo(Constants.BIG_DECIMAL_ZERO) > 0 || d.compareTo(Constants.BIG_DECIMAL_NEGATIVE_ONE) == 0; + } + + @Override + public Boolean createFromBit(byte[] bytes, int offset, int length) { + return createFromLong(DataTypeUtil.bitToLong(bytes, offset, length)); + } + + @Override + public Boolean createFromYear(long l) { + return createFromLong(l); + } + + public String getTargetTypeName() { + return Boolean.class.getName(); + } + + @Override + public Boolean createFromBytes(byte[] bytes, int offset, int length, Field f) { + if (length == 0 && this.pset.getBooleanProperty(PropertyKey.emptyStringsConvertToZero).getValue()) { + return createFromLong(0); + } + + String s = StringUtils.toString(bytes, offset, length, f.getEncoding()); + byte[] newBytes = s.getBytes(); + + if (s.equalsIgnoreCase("Y") || s.equalsIgnoreCase("true")) { + return createFromLong(1); + } else if (s.equalsIgnoreCase("N") || s.equalsIgnoreCase("false")) { + return createFromLong(0); + } else if (s.contains("e") || s.contains("E") || s.matches("-?\\d*\\.\\d*")) { + // floating point + return createFromDouble(MysqlTextValueDecoder.getDouble(newBytes, 0, newBytes.length)); + } else if (s.matches("-?\\d+")) { + // integer + if (s.charAt(0) == '-' // TODO shouldn't we check the length as well? + || length <= (MysqlTextValueDecoder.MAX_SIGNED_LONG_LEN - 1) && newBytes[0] >= '0' && newBytes[0] <= '8') { + return createFromLong(MysqlTextValueDecoder.getLong(newBytes, 0, newBytes.length)); + } + return createFromBigInteger(MysqlTextValueDecoder.getBigInteger(newBytes, 0, newBytes.length)); + } + throw new DataConversionException(Messages.getString("ResultSet.UnableToInterpretString", new Object[] { s })); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/BufferedRowList.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/BufferedRowList.java new file mode 100644 index 0000000..bd9601d --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/BufferedRowList.java @@ -0,0 +1,89 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.util.Iterator; +import java.util.List; +import java.util.NoSuchElementException; +import java.util.Spliterators; +import java.util.stream.Collectors; +import java.util.stream.StreamSupport; + +public class BufferedRowList implements RowList { + private List rowList; + private int position = -1; + + public BufferedRowList(List rowList) { + this.rowList = rowList; + } + + /** + * Create a new instance by filling the internal buffer by draining the row stream. + * + * @param ris + * {@link Row}s iterator + */ + public BufferedRowList(Iterator ris) { + this.rowList = StreamSupport.stream(Spliterators.spliteratorUnknownSize(ris, 0), false).collect(Collectors.toList()); + } + + public Row next() { + if (this.position + 1 == this.rowList.size()) { + throw new NoSuchElementException("Can't next() when position=" + this.position + " and size=" + this.rowList.size()); + } + return this.rowList.get(++this.position); + } + + public Row previous() { + if (this.position < 1) { + throw new NoSuchElementException("Can't previous() when position=" + this.position); + } + return this.rowList.get(--this.position); + } + + public Row get(int n) { + if (n < 0 || n >= this.rowList.size()) { + throw new NoSuchElementException("Can't get(" + n + ") when size=" + this.rowList.size()); + } + return this.rowList.get(n); + } + + public int getPosition() { + return this.position; + } + + public int size() { + return this.rowList.size(); + } + + public boolean hasNext() { + return this.position + 1 < this.rowList.size(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/ByteValueFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/ByteValueFactory.java new file mode 100644 index 0000000..07a966f --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/ByteValueFactory.java @@ -0,0 +1,117 @@ +/* + * Copyright (c) 2015, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.math.BigDecimal; +import java.math.BigInteger; + +import com.mysql.cj.Constants; +import com.mysql.cj.Messages; +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.NumberOutOfRange; +import com.mysql.cj.util.DataTypeUtil; +import com.mysql.cj.util.StringUtils; + +/** + * A value factory for creating byte values. + */ +public class ByteValueFactory extends DefaultValueFactory { + + public ByteValueFactory(PropertySet pset) { + super(pset); + } + + @Override + public Byte createFromBigInteger(BigInteger i) { + if (this.jdbcCompliantTruncationForReads + && (i.compareTo(Constants.BIG_INTEGER_MIN_BYTE_VALUE) < 0 || i.compareTo(Constants.BIG_INTEGER_MAX_BYTE_VALUE) > 0)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { i, getTargetTypeName() })); + } + return (byte) i.intValue(); + } + + @Override + public Byte createFromLong(long l) { + if (this.jdbcCompliantTruncationForReads && (l < Byte.MIN_VALUE || l > Byte.MAX_VALUE)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { Long.valueOf(l).toString(), getTargetTypeName() })); + } + return (byte) l; + } + + @Override + public Byte createFromBigDecimal(BigDecimal d) { + if (this.jdbcCompliantTruncationForReads + && (d.compareTo(Constants.BIG_DECIMAL_MIN_BYTE_VALUE) < 0 || d.compareTo(Constants.BIG_DECIMAL_MAX_BYTE_VALUE) > 0)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { d, getTargetTypeName() })); + } + return (byte) d.longValue(); + } + + @Override + public Byte createFromDouble(double d) { + if (this.jdbcCompliantTruncationForReads && (d < Byte.MIN_VALUE || d > Byte.MAX_VALUE)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { d, getTargetTypeName() })); + } + return (byte) d; + } + + @Override + public Byte createFromBit(byte[] bytes, int offset, int length) { + long l = DataTypeUtil.bitToLong(bytes, offset, length); + if (this.jdbcCompliantTruncationForReads && l >> 8 != 0) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { Long.valueOf(l).toString(), getTargetTypeName() })); + } + return (byte) l; + } + + @Override + public Byte createFromYear(long l) { + return createFromLong(l); + } + + public String getTargetTypeName() { + return Byte.class.getName(); + } + + @Override + public Byte createFromBytes(byte[] bytes, int offset, int length, Field f) { + if (length == 0 && this.pset.getBooleanProperty(PropertyKey.emptyStringsConvertToZero).getValue()) { + return (byte) 0; + } + String s = StringUtils.toString(bytes, offset, length, f.getEncoding()); + byte[] newBytes = s.getBytes(); + + if (this.jdbcCompliantTruncationForReads && newBytes.length != 1) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { s, getTargetTypeName() })); + } + return newBytes[0]; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/DefaultColumnDefinition.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/DefaultColumnDefinition.java new file mode 100644 index 0000000..6e7646f --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/DefaultColumnDefinition.java @@ -0,0 +1,239 @@ +/* + * Copyright (c) 2016, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.util.HashMap; +import java.util.Map; +import java.util.TreeMap; + +import com.mysql.cj.protocol.ColumnDefinition; + +/** + * Protocol::ColumnDefinition41 object + * + */ +public class DefaultColumnDefinition implements ColumnDefinition { + + protected Field[] fields; + + /** Map column names (and all of their permutations) to column indices */ + private Map columnLabelToIndex = null; + + /** + * The above map is a case-insensitive tree-map, it can be slow, this caches lookups into that map, because the other alternative is to create new + * object instances for every call to findColumn().... + */ + private Map columnToIndexCache = new HashMap<>(); + + /** Map of fully-specified column names to column indices */ + private Map fullColumnNameToIndex = null; + + /** Map column names (and all of their permutations) to column indices */ + private Map columnNameToIndex = null; + + private boolean builtIndexMapping = false; + + public DefaultColumnDefinition() { + } + + public DefaultColumnDefinition(Field[] fields) { + this.fields = fields; + } + + public Field[] getFields() { + return this.fields; + } + + public void setFields(Field[] fields) { + this.fields = fields; + } + + @Override + + /** + * Builds a hash between column names and their indices for fast retrieval. + */ + public void buildIndexMapping() { + int numFields = this.fields.length; + this.columnLabelToIndex = new TreeMap<>(String.CASE_INSENSITIVE_ORDER); + this.fullColumnNameToIndex = new TreeMap<>(String.CASE_INSENSITIVE_ORDER); + this.columnNameToIndex = new TreeMap<>(String.CASE_INSENSITIVE_ORDER); + + // We do this in reverse order, so that the 'first' column with a given name ends up as the final mapping in the hashtable... + // + // Quoting the JDBC Spec: + // + // "Column names used as input to getter methods are case insensitive. When a getter method is called with a column name and several columns have the + // same name, the value of the first matching column will be returned. " + // + for (int i = numFields - 1; i >= 0; i--) { + Integer index = Integer.valueOf(i); + String columnName = this.fields[i].getOriginalName(); + String columnLabel = this.fields[i].getName(); + String fullColumnName = this.fields[i].getFullName(); + + if (columnLabel != null) { + this.columnLabelToIndex.put(columnLabel, index); + } + + if (fullColumnName != null) { + this.fullColumnNameToIndex.put(fullColumnName, index); + } + + if (columnName != null) { + this.columnNameToIndex.put(columnName, index); + } + } + + // set the flag to prevent rebuilding... + this.builtIndexMapping = true; + } + + public boolean hasBuiltIndexMapping() { + return this.builtIndexMapping; + } + + public Map getColumnLabelToIndex() { + return this.columnLabelToIndex; + } + + public void setColumnLabelToIndex(Map columnLabelToIndex) { + this.columnLabelToIndex = columnLabelToIndex; + } + + public Map getFullColumnNameToIndex() { + return this.fullColumnNameToIndex; + } + + public void setFullColumnNameToIndex(Map fullColNameToIndex) { + this.fullColumnNameToIndex = fullColNameToIndex; + } + + public Map getColumnNameToIndex() { + return this.columnNameToIndex; + } + + public void setColumnNameToIndex(Map colNameToIndex) { + this.columnNameToIndex = colNameToIndex; + } + + public Map getColumnToIndexCache() { + return this.columnToIndexCache; + } + + public void setColumnToIndexCache(Map columnToIndexCache) { + this.columnToIndexCache = columnToIndexCache; + } + + public void initializeFrom(ColumnDefinition columnDefinition) { + this.fields = columnDefinition.getFields(); + this.columnLabelToIndex = columnDefinition.getColumnNameToIndex(); + this.fullColumnNameToIndex = columnDefinition.getFullColumnNameToIndex(); + this.builtIndexMapping = true; + } + + public void exportTo(ColumnDefinition columnDefinition) { + columnDefinition.setFields(this.fields); + columnDefinition.setColumnNameToIndex(this.columnLabelToIndex); + columnDefinition.setFullColumnNameToIndex(this.fullColumnNameToIndex); + } + + public int findColumn(String columnName, boolean useColumnNamesInFindColumn, int indexBase) { + + Integer index; + + if (!hasBuiltIndexMapping()) { + buildIndexMapping(); + } + + index = this.columnToIndexCache.get(columnName); + + if (index != null) { + return index.intValue() + indexBase; + } + + index = this.columnLabelToIndex.get(columnName); + + if (index == null && useColumnNamesInFindColumn) { + index = this.columnNameToIndex.get(columnName); + } + + if (index == null) { + index = this.fullColumnNameToIndex.get(columnName); + } + + if (index != null) { + this.columnToIndexCache.put(columnName, index); + + return index.intValue() + indexBase; + } + + // Try this inefficient way, now + + for (int i = 0; i < this.fields.length; i++) { + if (this.fields[i].getName().equalsIgnoreCase(columnName)) { + return i + indexBase; + } else if (this.fields[i].getFullName().equalsIgnoreCase(columnName)) { + return i + indexBase; + } + } + + return -1; + } + + /** + * Check if fields with type BLOB, MEDIUMBLOB, LONGBLOB, TEXT, MEDIUMTEXT or LONGTEXT + * exist in this ColumnDefinition. + * This check is used for making a decision about whether we want to force a + * buffer row (better for rows with large fields). + * + * @return true if this ColumnDefinition has large fields + */ + public boolean hasLargeFields() { + if (this.fields != null) { + for (int i = 0; i < this.fields.length; i++) { + switch (this.fields[i].getMysqlType()) { + case BLOB: + case MEDIUMBLOB: + case LONGBLOB: + case TEXT: + case MEDIUMTEXT: + case LONGTEXT: + case JSON: + return true; + default: + break; + } + } + } + return false; + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/DefaultValueFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/DefaultValueFactory.java new file mode 100644 index 0000000..4cb169e --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/DefaultValueFactory.java @@ -0,0 +1,118 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.math.BigDecimal; +import java.math.BigInteger; + +import com.mysql.cj.Messages; +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.DataConversionException; +import com.mysql.cj.protocol.InternalDate; +import com.mysql.cj.protocol.InternalTime; +import com.mysql.cj.protocol.InternalTimestamp; + +/** + * The default value factory provides a base class that can be used for value factories that do not support creation from every type. The default value factory + * will thrown an UnsupportedOperationException for every method and individual methods must be overridden by subclasses. + * + * @param + * value type + */ +public abstract class DefaultValueFactory implements ValueFactory { + + protected boolean jdbcCompliantTruncationForReads = true; + + public DefaultValueFactory(PropertySet pset) { + this.pset = pset; + + // TODO we always check initial value here, whatever the setupServerForTruncationChecks() does for writes. + // It also means that runtime changes of this variable have no effect on reads. + this.jdbcCompliantTruncationForReads = this.pset.getBooleanProperty(PropertyKey.jdbcCompliantTruncation).getInitialValue(); + } + + protected PropertySet pset = null; + + @Override + public void setPropertySet(PropertySet pset) { + this.pset = pset; + } + + protected T unsupported(String sourceType) { + throw new DataConversionException(Messages.getString("ResultSet.UnsupportedConversion", new Object[] { sourceType, getTargetTypeName() })); + } + + public T createFromDate(InternalDate idate) { + return unsupported("DATE"); + } + + public T createFromTime(InternalTime it) { + return unsupported("TIME"); + } + + public T createFromTimestamp(InternalTimestamp its) { + return unsupported("TIMESTAMP"); + } + + @Override + public T createFromDatetime(InternalTimestamp its) { + return unsupported("DATETIME"); + } + + public T createFromLong(long l) { + return unsupported("LONG"); + } + + public T createFromBigInteger(BigInteger i) { + return unsupported("BIGINT"); + } + + public T createFromDouble(double d) { + return unsupported("DOUBLE"); + } + + public T createFromBigDecimal(BigDecimal d) { + return unsupported("DECIMAL"); + } + + public T createFromBit(byte[] bytes, int offset, int length) { + return unsupported("BIT"); + } + + @Override + public T createFromYear(long l) { + return unsupported("YEAR"); + } + + public T createFromNull() { + return null; + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/DoubleValueFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/DoubleValueFactory.java new file mode 100644 index 0000000..1da7ddf --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/DoubleValueFactory.java @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.nio.ByteBuffer; + +import com.mysql.cj.Constants; +import com.mysql.cj.Messages; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.NumberOutOfRange; + +/** + * A value factory for creating double values. + */ +public class DoubleValueFactory extends AbstractNumericValueFactory { + + public DoubleValueFactory(PropertySet pset) { + super(pset); + } + + @Override + public Double createFromBigInteger(BigInteger i) { + if (this.jdbcCompliantTruncationForReads && (new BigDecimal(i).compareTo(Constants.BIG_DECIMAL_MAX_NEGATIVE_DOUBLE_VALUE) < 0 + || new BigDecimal(i).compareTo(Constants.BIG_DECIMAL_MAX_DOUBLE_VALUE) > 0)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { i, getTargetTypeName() })); + } + return i.doubleValue(); + } + + @Override + public Double createFromLong(long l) { + if (this.jdbcCompliantTruncationForReads && (l < -Double.MAX_VALUE || l > Double.MAX_VALUE)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { l, getTargetTypeName() })); + } + return (double) l; + } + + @Override + public Double createFromBigDecimal(BigDecimal d) { + if (this.jdbcCompliantTruncationForReads + && (d.compareTo(Constants.BIG_DECIMAL_MAX_NEGATIVE_DOUBLE_VALUE) < 0 || d.compareTo(Constants.BIG_DECIMAL_MAX_DOUBLE_VALUE) > 0)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { d, getTargetTypeName() })); + } + return d.doubleValue(); + } + + @Override + public Double createFromDouble(double d) { + if (this.jdbcCompliantTruncationForReads && (d < -Double.MAX_VALUE || d > Double.MAX_VALUE)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { d, getTargetTypeName() })); + } + return d; + } + + @Override + public Double createFromBit(byte[] bytes, int offset, int length) { + return new BigInteger(ByteBuffer.allocate(length + 1).put((byte) 0).put(bytes, offset, length).array()).doubleValue(); + } + + public String getTargetTypeName() { + return Double.class.getName(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/DurationValueFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/DurationValueFactory.java new file mode 100644 index 0000000..77f92f7 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/DurationValueFactory.java @@ -0,0 +1,74 @@ +/* + * Copyright (c) 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.time.Duration; + +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.protocol.InternalDate; +import com.mysql.cj.protocol.InternalTime; +import com.mysql.cj.protocol.InternalTimestamp; + +/** + * A value factory to create {@link Duration} instances. + */ +public class DurationValueFactory extends AbstractDateTimeValueFactory { + + public DurationValueFactory(PropertySet pset) { + super(pset); + } + + @Override + Duration localCreateFromDate(InternalDate idate) { + return unsupported("DATE"); + } + + @Override + public Duration localCreateFromTime(InternalTime it) { + String ptn = (it.getHours() < 0 ? "-PT" : "PT") + (it.getHours() < 0 ? -it.getHours() : it.getHours()) + "H" + it.getMinutes() + "M" + it.getSeconds() + + "." + it.getNanos() + "S"; + return Duration.parse(ptn); + } + + @Override + public Duration localCreateFromTimestamp(InternalTimestamp its) { + return unsupported("TIMESTAMP"); + } + + @Override + public Duration localCreateFromDatetime(InternalTimestamp its) { + return unsupported("DATETIME"); + } + + public String getTargetTypeName() { + return Duration.class.getName(); + } + +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/FloatValueFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/FloatValueFactory.java new file mode 100644 index 0000000..38f231e --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/FloatValueFactory.java @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.nio.ByteBuffer; + +import com.mysql.cj.Constants; +import com.mysql.cj.Messages; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.NumberOutOfRange; + +/** + * A value factory for creating float values. + */ +public class FloatValueFactory extends AbstractNumericValueFactory { + + public FloatValueFactory(PropertySet pset) { + super(pset); + } + + @Override + public Float createFromBigInteger(BigInteger i) { + if (this.jdbcCompliantTruncationForReads && (new BigDecimal(i).compareTo(Constants.BIG_DECIMAL_MAX_NEGATIVE_FLOAT_VALUE) < 0 + || new BigDecimal(i).compareTo(Constants.BIG_DECIMAL_MAX_FLOAT_VALUE) > 0)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { i, getTargetTypeName() })); + } + return (float) i.doubleValue(); + } + + @Override + public Float createFromLong(long l) { + if (this.jdbcCompliantTruncationForReads && (l < -Float.MAX_VALUE || l > Float.MAX_VALUE)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { l, getTargetTypeName() })); + } + return (float) l; + } + + @Override + public Float createFromBigDecimal(BigDecimal d) { + if (this.jdbcCompliantTruncationForReads + && (d.compareTo(Constants.BIG_DECIMAL_MAX_NEGATIVE_FLOAT_VALUE) < 0 || d.compareTo(Constants.BIG_DECIMAL_MAX_FLOAT_VALUE) > 0)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { d, getTargetTypeName() })); + } + return (float) d.doubleValue(); + } + + @Override + public Float createFromDouble(double d) { + if (this.jdbcCompliantTruncationForReads && (d < -Float.MAX_VALUE || d > Float.MAX_VALUE)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { d, getTargetTypeName() })); + } + return (float) d; + } + + @Override + public Float createFromBit(byte[] bytes, int offset, int length) { + return new BigInteger(ByteBuffer.allocate(length + 1).put((byte) 0).put(bytes, offset, length).array()).floatValue(); + } + + public String getTargetTypeName() { + return Float.class.getName(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/IntegerValueFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/IntegerValueFactory.java new file mode 100644 index 0000000..744ee21 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/IntegerValueFactory.java @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.math.BigDecimal; +import java.math.BigInteger; + +import com.mysql.cj.Constants; +import com.mysql.cj.Messages; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.NumberOutOfRange; +import com.mysql.cj.util.DataTypeUtil; + +/** + * A value factory for creating int values. + */ +public class IntegerValueFactory extends AbstractNumericValueFactory { + + public IntegerValueFactory(PropertySet pset) { + super(pset); + } + + @Override + public Integer createFromBigInteger(BigInteger i) { + if (this.jdbcCompliantTruncationForReads + && (i.compareTo(Constants.BIG_INTEGER_MIN_INTEGER_VALUE) < 0 || i.compareTo(Constants.BIG_INTEGER_MAX_INTEGER_VALUE) > 0)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { i, getTargetTypeName() })); + } + return i.intValue(); + } + + @Override + public Integer createFromLong(long l) { + if (this.jdbcCompliantTruncationForReads && (l < Integer.MIN_VALUE || l > Integer.MAX_VALUE)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { Long.valueOf(l).toString(), getTargetTypeName() })); + } + return (int) l; + } + + @Override + public Integer createFromBigDecimal(BigDecimal d) { + if (this.jdbcCompliantTruncationForReads + && (d.compareTo(Constants.BIG_DECIMAL_MIN_INTEGER_VALUE) < 0 || d.compareTo(Constants.BIG_DECIMAL_MAX_INTEGER_VALUE) > 0)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { d, getTargetTypeName() })); + } + return (int) d.longValue(); + } + + @Override + public Integer createFromDouble(double d) { + if (this.jdbcCompliantTruncationForReads && (d < Integer.MIN_VALUE || d > Integer.MAX_VALUE)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { d, getTargetTypeName() })); + } + return (int) d; + } + + @Override + public Integer createFromBit(byte[] bytes, int offset, int length) { + long l = DataTypeUtil.bitToLong(bytes, offset, length); + if (this.jdbcCompliantTruncationForReads && l >> 32 != 0) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { Long.valueOf(l).toString(), getTargetTypeName() })); + } + return (int) l; + } + + public String getTargetTypeName() { + return Integer.class.getName(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/LocalDateTimeValueFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/LocalDateTimeValueFactory.java new file mode 100644 index 0000000..2fe3127 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/LocalDateTimeValueFactory.java @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2016, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.time.LocalDateTime; + +import com.mysql.cj.Messages; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.DataReadException; +import com.mysql.cj.protocol.InternalDate; +import com.mysql.cj.protocol.InternalTime; +import com.mysql.cj.protocol.InternalTimestamp; + +/** + * Value factory to create {@link LocalDateTime} instances. + */ +public class LocalDateTimeValueFactory extends AbstractDateTimeValueFactory { + + public LocalDateTimeValueFactory(PropertySet pset) { + super(pset); + } + + /** + * Create a LocalDateTime from a DATE value. + * + * @return a LocalDateTime at midnight on the day given by the DATE value + */ + @Override + public LocalDateTime localCreateFromDate(InternalDate idate) { + return createFromTimestamp(new InternalTimestamp(idate.getYear(), idate.getMonth(), idate.getDay(), 0, 0, 0, 0, 0)); + } + + /** + * Create a LocalDateTime from a TIME value. + * + * @return a LocalDateTime at the given time on 1970 Jan 1. + */ + @Override + public LocalDateTime localCreateFromTime(InternalTime it) { + if (it.getHours() < 0 || it.getHours() >= 24) { + throw new DataReadException(Messages.getString("ResultSet.InvalidTimeValue", new Object[] { it.toString() })); + } + return createFromTimestamp(new InternalTimestamp(1970, 1, 1, it.getHours(), it.getMinutes(), it.getSeconds(), it.getNanos(), it.getScale())); + } + + @Override + public LocalDateTime localCreateFromTimestamp(InternalTimestamp its) { + if (its.getYear() == 0 && its.getMonth() == 0 && its.getDay() == 0) { + throw new DataReadException(Messages.getString("ResultSet.InvalidZeroDate")); + } + return LocalDateTime.of(its.getYear(), its.getMonth(), its.getDay(), its.getHours(), its.getMinutes(), its.getSeconds(), its.getNanos()); + } + + @Override + public LocalDateTime localCreateFromDatetime(InternalTimestamp its) { + if (its.getYear() == 0 && its.getMonth() == 0 && its.getDay() == 0) { + throw new DataReadException(Messages.getString("ResultSet.InvalidZeroDate")); + } + return LocalDateTime.of(its.getYear(), its.getMonth(), its.getDay(), its.getHours(), its.getMinutes(), its.getSeconds(), its.getNanos()); + } + + public String getTargetTypeName() { + return LocalDateTime.class.getName(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/LocalDateValueFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/LocalDateValueFactory.java new file mode 100644 index 0000000..9a8c9b0 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/LocalDateValueFactory.java @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2016, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.time.LocalDate; + +import com.mysql.cj.Messages; +import com.mysql.cj.WarningListener; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.DataReadException; +import com.mysql.cj.protocol.InternalDate; +import com.mysql.cj.protocol.InternalTime; +import com.mysql.cj.protocol.InternalTimestamp; + +/** + * A value factory for creating {@link LocalDate} values. + */ +public class LocalDateValueFactory extends AbstractDateTimeValueFactory { + private WarningListener warningListener; + + public LocalDateValueFactory(PropertySet pset) { + super(pset); + } + + public LocalDateValueFactory(PropertySet pset, WarningListener warningListener) { + this(pset); + this.warningListener = warningListener; + } + + @Override + public LocalDate localCreateFromDate(InternalDate idate) { + if (idate.getYear() == 0 && idate.getMonth() == 0 && idate.getDay() == 0) { + throw new DataReadException(Messages.getString("ResultSet.InvalidZeroDate")); + } + return LocalDate.of(idate.getYear(), idate.getMonth(), idate.getDay()); + } + + @Override + public LocalDate localCreateFromTimestamp(InternalTimestamp its) { + if (this.warningListener != null) { + this.warningListener.warningEncountered(Messages.getString("ResultSet.PrecisionLostWarning", new Object[] { getTargetTypeName() })); + } + // truncate any time information + return createFromDate(its); + } + + @Override + public LocalDate localCreateFromDatetime(InternalTimestamp its) { + if (this.warningListener != null) { + this.warningListener.warningEncountered(Messages.getString("ResultSet.PrecisionLostWarning", new Object[] { getTargetTypeName() })); + } + // truncate any time information + return createFromDate(its); + } + + @Override + LocalDate localCreateFromTime(InternalTime it) { + return LocalDate.of(1970, 1, 1); + } + + public String getTargetTypeName() { + return LocalDate.class.getName(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/LocalTimeValueFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/LocalTimeValueFactory.java new file mode 100644 index 0000000..2b7b808 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/LocalTimeValueFactory.java @@ -0,0 +1,91 @@ +/* + * Copyright (c) 2016, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.time.LocalTime; + +import com.mysql.cj.Messages; +import com.mysql.cj.WarningListener; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.DataReadException; +import com.mysql.cj.protocol.InternalDate; +import com.mysql.cj.protocol.InternalTime; +import com.mysql.cj.protocol.InternalTimestamp; + +/** + * A value factory to create {@link LocalTime} instances. + */ +public class LocalTimeValueFactory extends AbstractDateTimeValueFactory { + private WarningListener warningListener; + + public LocalTimeValueFactory(PropertySet pset) { + super(pset); + } + + public LocalTimeValueFactory(PropertySet pset, WarningListener warningListener) { + this(pset); + this.warningListener = warningListener; + } + + @Override + LocalTime localCreateFromDate(InternalDate idate) { + return LocalTime.of(0, 0); + } + + @Override + public LocalTime localCreateFromTime(InternalTime it) { + if (it.getHours() < 0 || it.getHours() >= 24) { + throw new DataReadException(Messages.getString("ResultSet.InvalidTimeValue", new Object[] { it.toString() })); + } + return LocalTime.of(it.getHours(), it.getMinutes(), it.getSeconds(), it.getNanos()); + } + + @Override + public LocalTime localCreateFromTimestamp(InternalTimestamp its) { + if (this.warningListener != null) { + this.warningListener.warningEncountered(Messages.getString("ResultSet.PrecisionLostWarning", new Object[] { getTargetTypeName() })); + } + // truncate date information + return createFromTime(new InternalTime(its.getHours(), its.getMinutes(), its.getSeconds(), its.getNanos(), its.getScale())); + } + + @Override + public LocalTime localCreateFromDatetime(InternalTimestamp its) { + if (this.warningListener != null) { + this.warningListener.warningEncountered(Messages.getString("ResultSet.PrecisionLostWarning", new Object[] { getTargetTypeName() })); + } + // truncate date information + return createFromTime(new InternalTime(its.getHours(), its.getMinutes(), its.getSeconds(), its.getNanos(), its.getScale())); + } + + public String getTargetTypeName() { + return LocalTime.class.getName(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/LongValueFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/LongValueFactory.java new file mode 100644 index 0000000..8a39927 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/LongValueFactory.java @@ -0,0 +1,92 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.math.BigDecimal; +import java.math.BigInteger; + +import com.mysql.cj.Constants; +import com.mysql.cj.Messages; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.NumberOutOfRange; +import com.mysql.cj.util.DataTypeUtil; + +/** + * A value factory for creating long values. + */ +public class LongValueFactory extends AbstractNumericValueFactory { + + public LongValueFactory(PropertySet pset) { + super(pset); + } + + @Override + public Long createFromBigInteger(BigInteger i) { + if (this.jdbcCompliantTruncationForReads + && (i.compareTo(Constants.BIG_INTEGER_MIN_LONG_VALUE) < 0 || i.compareTo(Constants.BIG_INTEGER_MAX_LONG_VALUE) > 0)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { i, getTargetTypeName() })); + } + return i.longValue(); + } + + @Override + public Long createFromLong(long l) { + if (this.jdbcCompliantTruncationForReads && (l < Long.MIN_VALUE || l > Long.MAX_VALUE)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { Long.valueOf(l).toString(), getTargetTypeName() })); + } + return l; + } + + @Override + public Long createFromBigDecimal(BigDecimal d) { + if (this.jdbcCompliantTruncationForReads + && (d.compareTo(Constants.BIG_DECIMAL_MIN_LONG_VALUE) < 0 || d.compareTo(Constants.BIG_DECIMAL_MAX_LONG_VALUE) > 0)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { d, getTargetTypeName() })); + } + return d.longValue(); + } + + @Override + public Long createFromDouble(double d) { + if (this.jdbcCompliantTruncationForReads && (d < Long.MIN_VALUE || d > Long.MAX_VALUE)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { d, getTargetTypeName() })); + } + return (long) d; + } + + @Override + public Long createFromBit(byte[] bytes, int offset, int length) { + return DataTypeUtil.bitToLong(bytes, offset, length); + } + + public String getTargetTypeName() { + return Long.class.getName(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/OffsetDateTimeValueFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/OffsetDateTimeValueFactory.java new file mode 100644 index 0000000..af6f8c8 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/OffsetDateTimeValueFactory.java @@ -0,0 +1,140 @@ +/* + * Copyright (c) 2020, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.time.LocalDateTime; +import java.time.OffsetDateTime; +import java.time.format.DateTimeParseException; +import java.util.TimeZone; + +import com.mysql.cj.Messages; +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.DataConversionException; +import com.mysql.cj.exceptions.DataReadException; +import com.mysql.cj.protocol.InternalDate; +import com.mysql.cj.protocol.InternalTime; +import com.mysql.cj.protocol.InternalTimestamp; +import com.mysql.cj.protocol.a.MysqlTextValueDecoder; +import com.mysql.cj.util.StringUtils; + +/** + * Value factory to create {@link OffsetDateTime} instances. + */ +public class OffsetDateTimeValueFactory extends AbstractDateTimeValueFactory { + + private TimeZone defaultTimeZone; + private TimeZone connectionTimeZone; + + public OffsetDateTimeValueFactory(PropertySet pset, TimeZone defaultTimeZone, TimeZone connectionTimeZone) { + super(pset); + this.defaultTimeZone = defaultTimeZone; + this.connectionTimeZone = connectionTimeZone; + } + + /** + * Create an OffsetDateTime from a DATE value. + * + * @return an OffsetDateTime at midnight on the day given by the DATE value + */ + @Override + public OffsetDateTime localCreateFromDate(InternalDate idate) { + if (idate.getYear() == 0 && idate.getMonth() == 0 && idate.getDay() == 0) { + throw new DataReadException(Messages.getString("ResultSet.InvalidZeroDate")); + } + return LocalDateTime.of(idate.getYear(), idate.getMonth(), idate.getDay(), 0, 0, 0, 0).atZone(this.defaultTimeZone.toZoneId()).toOffsetDateTime(); + } + + /** + * Create an OffsetDateTime from a TIME value. + * + * @return an OffsetDateTime at the given time on 1970 Jan 1. + */ + @Override + public OffsetDateTime localCreateFromTime(InternalTime it) { + if (it.getHours() < 0 || it.getHours() >= 24) { + throw new DataReadException(Messages.getString("ResultSet.InvalidTimeValue", new Object[] { it.toString() })); + } + return LocalDateTime.of(1970, 1, 1, it.getHours(), it.getMinutes(), it.getSeconds(), it.getNanos()).atZone(this.defaultTimeZone.toZoneId()) + .toOffsetDateTime(); + } + + @Override + public OffsetDateTime localCreateFromTimestamp(InternalTimestamp its) { + if (its.getYear() == 0 && its.getMonth() == 0 && its.getDay() == 0) { + throw new DataReadException(Messages.getString("ResultSet.InvalidZeroDate")); + } + return LocalDateTime.of(its.getYear(), its.getMonth(), its.getDay(), its.getHours(), its.getMinutes(), its.getSeconds(), its.getNanos()) + .atZone((this.pset.getBooleanProperty(PropertyKey.preserveInstants).getValue() ? this.connectionTimeZone : this.defaultTimeZone).toZoneId()) + .toOffsetDateTime(); + } + + @Override + public OffsetDateTime localCreateFromDatetime(InternalTimestamp its) { + if (its.getYear() == 0 && its.getMonth() == 0 && its.getDay() == 0) { + throw new DataReadException(Messages.getString("ResultSet.InvalidZeroDate")); + } + return LocalDateTime.of(its.getYear(), its.getMonth(), its.getDay(), its.getHours(), its.getMinutes(), its.getSeconds(), its.getNanos()) + .atZone((this.pset.getBooleanProperty(PropertyKey.preserveInstants).getValue() ? this.connectionTimeZone : this.defaultTimeZone).toZoneId()) + .toOffsetDateTime(); + } + + @Override + public OffsetDateTime createFromBytes(byte[] bytes, int offset, int length, Field f) { + if (length == 0 && this.pset.getBooleanProperty(PropertyKey.emptyStringsConvertToZero).getValue()) { + return createFromLong(0); + } + + String s = StringUtils.toString(bytes, offset, length, f.getEncoding()); + byte[] newBytes = s.getBytes(); + + if (MysqlTextValueDecoder.isDate(s)) { + return createFromDate(MysqlTextValueDecoder.getDate(newBytes, 0, newBytes.length)); + + } else if (MysqlTextValueDecoder.isTime(s)) { + return createFromTime(MysqlTextValueDecoder.getTime(newBytes, 0, newBytes.length, f.getDecimals())); + + } else if (MysqlTextValueDecoder.isTimestamp(s)) { + return createFromTimestamp(MysqlTextValueDecoder.getTimestamp(newBytes, 0, newBytes.length, f.getDecimals())); + } + + // by default try to parse + try { + return OffsetDateTime.parse(s.replace(" ", "T")); + } catch (DateTimeParseException e) { + throw new DataConversionException(Messages.getString("ResultSet.UnableToConvertString", new Object[] { s, getTargetTypeName() })); + } + + } + + public String getTargetTypeName() { + return OffsetDateTime.class.getName(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/OffsetTimeValueFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/OffsetTimeValueFactory.java new file mode 100644 index 0000000..9e1ae72 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/OffsetTimeValueFactory.java @@ -0,0 +1,128 @@ +/* + * Copyright (c) 2020, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.time.LocalTime; +import java.time.OffsetTime; +import java.time.ZoneOffset; +import java.time.format.DateTimeParseException; +import java.util.TimeZone; + +import com.mysql.cj.Messages; +import com.mysql.cj.WarningListener; +import com.mysql.cj.conf.PropertyKey; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.DataConversionException; +import com.mysql.cj.exceptions.DataReadException; +import com.mysql.cj.protocol.InternalDate; +import com.mysql.cj.protocol.InternalTime; +import com.mysql.cj.protocol.InternalTimestamp; +import com.mysql.cj.protocol.a.MysqlTextValueDecoder; +import com.mysql.cj.util.StringUtils; + +/** + * A value factory to create {@link OffsetTime} instances. + */ +public class OffsetTimeValueFactory extends AbstractDateTimeValueFactory { + private WarningListener warningListener; + private TimeZone tz; + + public OffsetTimeValueFactory(PropertySet pset, TimeZone tz) { + super(pset); + this.tz = tz; + } + + public OffsetTimeValueFactory(PropertySet pset, TimeZone tz, WarningListener warningListener) { + this(pset, tz); + this.warningListener = warningListener; + } + + @Override + OffsetTime localCreateFromDate(InternalDate idate) { + return LocalTime.of(0, 0).atOffset(ZoneOffset.ofTotalSeconds(this.tz.getRawOffset() / 1000)); + } + + @Override + public OffsetTime localCreateFromTime(InternalTime it) { + if (it.getHours() < 0 || it.getHours() >= 24) { + throw new DataReadException(Messages.getString("ResultSet.InvalidTimeValue", new Object[] { it.toString() })); + } + return LocalTime.of(it.getHours(), it.getMinutes(), it.getSeconds(), it.getNanos()).atOffset(ZoneOffset.ofTotalSeconds(this.tz.getRawOffset() / 1000)); + } + + @Override + public OffsetTime localCreateFromTimestamp(InternalTimestamp its) { + if (this.warningListener != null) { + this.warningListener.warningEncountered(Messages.getString("ResultSet.PrecisionLostWarning", new Object[] { getTargetTypeName() })); + } + // truncate date information + return createFromTime(new InternalTime(its.getHours(), its.getMinutes(), its.getSeconds(), its.getNanos(), its.getScale())); + } + + @Override + public OffsetTime localCreateFromDatetime(InternalTimestamp its) { + if (this.warningListener != null) { + this.warningListener.warningEncountered(Messages.getString("ResultSet.PrecisionLostWarning", new Object[] { getTargetTypeName() })); + } + // truncate date information + return createFromTime(new InternalTime(its.getHours(), its.getMinutes(), its.getSeconds(), its.getNanos(), its.getScale())); + } + + @Override + public OffsetTime createFromBytes(byte[] bytes, int offset, int length, Field f) { + if (length == 0 && this.pset.getBooleanProperty(PropertyKey.emptyStringsConvertToZero).getValue()) { + return createFromLong(0); + } + + String s = StringUtils.toString(bytes, offset, length, f.getEncoding()); + byte[] newBytes = s.getBytes(); + + if (MysqlTextValueDecoder.isDate(s)) { + return createFromDate(MysqlTextValueDecoder.getDate(newBytes, 0, newBytes.length)); + + } else if (MysqlTextValueDecoder.isTime(s)) { + return createFromTime(MysqlTextValueDecoder.getTime(newBytes, 0, newBytes.length, f.getDecimals())); + + } else if (MysqlTextValueDecoder.isTimestamp(s)) { + return createFromTimestamp(MysqlTextValueDecoder.getTimestamp(newBytes, 0, newBytes.length, f.getDecimals())); + } + + // by default try to parse + try { + return OffsetTime.parse(s); + } catch (DateTimeParseException e) { + throw new DataConversionException(Messages.getString("ResultSet.UnableToConvertString", new Object[] { s, getTargetTypeName() })); + } + } + + public String getTargetTypeName() { + return OffsetTime.class.getName(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/ShortValueFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/ShortValueFactory.java new file mode 100644 index 0000000..52a225f --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/ShortValueFactory.java @@ -0,0 +1,96 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.math.BigDecimal; +import java.math.BigInteger; + +import com.mysql.cj.Constants; +import com.mysql.cj.Messages; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.NumberOutOfRange; +import com.mysql.cj.util.DataTypeUtil; + +/** + * A value factory for creating short values. + */ +public class ShortValueFactory extends AbstractNumericValueFactory { + + public ShortValueFactory(PropertySet pset) { + super(pset); + } + + @Override + public Short createFromBigInteger(BigInteger i) { + if (this.jdbcCompliantTruncationForReads + && (i.compareTo(Constants.BIG_INTEGER_MIN_SHORT_VALUE) < 0 || i.compareTo(Constants.BIG_INTEGER_MAX_SHORT_VALUE) > 0)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { i, getTargetTypeName() })); + } + return (short) i.intValue(); + } + + @Override + public Short createFromLong(long l) { + if (this.jdbcCompliantTruncationForReads && (l < Short.MIN_VALUE || l > Short.MAX_VALUE)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { Long.valueOf(l).toString(), getTargetTypeName() })); + } + return (short) l; + } + + @Override + public Short createFromBigDecimal(BigDecimal d) { + if (this.jdbcCompliantTruncationForReads + && (d.compareTo(Constants.BIG_DECIMAL_MIN_SHORT_VALUE) < 0 || d.compareTo(Constants.BIG_DECIMAL_MAX_SHORT_VALUE) > 0)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { d, getTargetTypeName() })); + } + return (short) d.longValue(); + } + + @Override + public Short createFromDouble(double d) { + if (this.jdbcCompliantTruncationForReads && (d < Short.MIN_VALUE || d > Short.MAX_VALUE)) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { d, getTargetTypeName() })); + } + return (short) d; + } + + @Override + public Short createFromBit(byte[] bytes, int offset, int length) { + long l = DataTypeUtil.bitToLong(bytes, offset, length); + if (this.jdbcCompliantTruncationForReads && l >> 16 != 0) { + throw new NumberOutOfRange(Messages.getString("ResultSet.NumberOutOfRange", new Object[] { Long.valueOf(l).toString(), getTargetTypeName() })); + } + return (short) l; + } + + public String getTargetTypeName() { + return Short.class.getName(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/SqlDateValueFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/SqlDateValueFactory.java new file mode 100644 index 0000000..e1d7904 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/SqlDateValueFactory.java @@ -0,0 +1,126 @@ +/* + * Copyright (c) 2015, 2020, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.sql.Date; +import java.time.LocalDate; +import java.util.Calendar; +import java.util.Locale; +import java.util.TimeZone; + +import com.mysql.cj.Messages; +import com.mysql.cj.WarningListener; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.DataReadException; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.WrongArgumentException; +import com.mysql.cj.protocol.InternalDate; +import com.mysql.cj.protocol.InternalTime; +import com.mysql.cj.protocol.InternalTimestamp; + +/** + * A value factory for creating {@link java.sql.Date} values. + */ +public class SqlDateValueFactory extends AbstractDateTimeValueFactory { + private WarningListener warningListener; + // cached per instance to avoid re-creation on every create*() call + private Calendar cal; + + public SqlDateValueFactory(PropertySet pset, Calendar calendar, TimeZone tz) { + super(pset); + if (calendar != null) { + this.cal = (Calendar) calendar.clone(); + } else { + // c.f. Bug#11540 for details on locale + this.cal = Calendar.getInstance(tz, Locale.US); + this.cal.set(Calendar.MILLISECOND, 0); + this.cal.setLenient(false); + } + } + + public SqlDateValueFactory(PropertySet pset, Calendar calendar, TimeZone tz, WarningListener warningListener) { + this(pset, calendar, tz); + this.warningListener = warningListener; + } + + @Override + public Date localCreateFromDate(InternalDate idate) { + synchronized (this.cal) { + try { + if (idate.isZero()) { + throw new DataReadException(Messages.getString("ResultSet.InvalidZeroDate")); + } + + this.cal.clear(); + this.cal.set(idate.getYear(), idate.getMonth() - 1, idate.getDay()); + long ms = this.cal.getTimeInMillis(); + return new Date(ms); + } catch (IllegalArgumentException e) { + throw ExceptionFactory.createException(WrongArgumentException.class, e.getMessage(), e); + } + } + } + + @Override + public Date localCreateFromTime(InternalTime it) { + if (this.warningListener != null) { + // TODO: need column context + this.warningListener.warningEncountered(Messages.getString("ResultSet.ImplicitDatePartWarning", new Object[] { "java.sql.Date" })); + } + + return Date.valueOf(LocalDate.of(1970, 1, 1)); + } + + @Override + public Date localCreateFromTimestamp(InternalTimestamp its) { + if (this.warningListener != null) { + // TODO: need column context + this.warningListener.warningEncountered(Messages.getString("ResultSet.PrecisionLostWarning", new Object[] { "java.sql.Date" })); + } + + // truncate any time information + return createFromDate(its); + } + + @Override + public Date localCreateFromDatetime(InternalTimestamp its) { + if (this.warningListener != null) { + // TODO: need column context + this.warningListener.warningEncountered(Messages.getString("ResultSet.PrecisionLostWarning", new Object[] { "java.sql.Date" })); + } + + // truncate any time information + return createFromDate(its); + } + + public String getTargetTypeName() { + return Date.class.getName(); + } +} diff --git a/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/SqlTimeValueFactory.java b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/SqlTimeValueFactory.java new file mode 100644 index 0000000..a4d37e9 --- /dev/null +++ b/EcurieJavaApp/Ecurie_ccunatbrule/mysql-connector-java-8.0.26/src/main/core-impl/java/com/mysql/cj/result/SqlTimeValueFactory.java @@ -0,0 +1,128 @@ +/* + * Copyright (c) 2015, 2021, Oracle and/or its affiliates. + * + * This program is free software; you can redistribute it and/or modify it under + * the terms of the GNU General Public License, version 2.0, as published by the + * Free Software Foundation. + * + * This program is also distributed with certain software (including but not + * limited to OpenSSL) that is licensed under separate terms, as designated in a + * particular file or component or in included license documentation. The + * authors of MySQL hereby grant you an additional permission to link the + * program and your derivative works with the separately licensed software that + * they have included with MySQL. + * + * Without limiting anything contained in the foregoing, this file, which is + * part of MySQL Connector/J, is also subject to the Universal FOSS Exception, + * version 1.0, a copy of which can be found at + * http://oss.oracle.com/licenses/universal-foss-exception. + * + * This program is distributed in the hope that it will be useful, but WITHOUT + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS + * FOR A PARTICULAR PURPOSE. See the GNU General Public License, version 2.0, + * for more details. + * + * You should have received a copy of the GNU General Public License along with + * this program; if not, write to the Free Software Foundation, Inc., + * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +package com.mysql.cj.result; + +import java.sql.Time; +import java.util.Calendar; +import java.util.Locale; +import java.util.TimeZone; + +import com.mysql.cj.Messages; +import com.mysql.cj.WarningListener; +import com.mysql.cj.conf.PropertySet; +import com.mysql.cj.exceptions.DataReadException; +import com.mysql.cj.exceptions.ExceptionFactory; +import com.mysql.cj.exceptions.WrongArgumentException; +import com.mysql.cj.protocol.InternalDate; +import com.mysql.cj.protocol.InternalTime; +import com.mysql.cj.protocol.InternalTimestamp; + +/** + * A value factory to create {@link java.sql.Time} instances. As with other date/time types, a time zone is necessary to interpret the + * time values returned from the server. + */ +public class SqlTimeValueFactory extends AbstractDateTimeValueFactory