summaryrefslogtreecommitdiff
path: root/python-hivejdbc.spec
diff options
context:
space:
mode:
Diffstat (limited to 'python-hivejdbc.spec')
-rw-r--r--python-hivejdbc.spec904
1 files changed, 904 insertions, 0 deletions
diff --git a/python-hivejdbc.spec b/python-hivejdbc.spec
new file mode 100644
index 0000000..4a8e362
--- /dev/null
+++ b/python-hivejdbc.spec
@@ -0,0 +1,904 @@
+%global _empty_manifest_terminate_build 0
+Name: python-hivejdbc
+Version: 0.2.3
+Release: 1
+Summary: Hive database driver via jdbc
+License: Apache-2.0
+URL: https://github.com/OpenBigDataPlatform/hivejdbc
+Source0: https://mirrors.nju.edu.cn/pypi/web/packages/b8/4b/d3f2a7c28654e84003efd133ca60ce79c41bc1bad681fc9058fb932a64ff/hivejdbc-0.2.3.tar.gz
+BuildArch: noarch
+
+Requires: python3-pyjdbc
+
+%description
+# hivejdbc
+hivejdbc is `db-api-2.0` compliant **Apache Hive** driver that supports
+- kerberos
+- ssl
+- service discovery via zookeeper
+- host-connection list
+- and all other jdbc driver options
+
+# installation
+```properties
+pip3 install hivejdbc
+```
+
+## Cursors
+`hivejdbc` can use a `dictonary` cursor if desired.
+
+```python
+from hivejdbc import connect, DictCursor
+conn = connect('example.com', 'default', cursor=DictCursor)
+
+```
+
+### Cursors support `with`
+```python
+from hivejdbc import connect
+conn = connect('example.com', database='default')
+with conn.cursor() as cursor:
+ cursor.execute('select * from test.persons')
+ rows = cursor.fetchall()
+```
+
+### Cursors are iterable
+```python
+from hivejdbc import connect
+conn = connect('example.com', database='default')
+cursor = conn.cursor()
+cursor.execute('select * from test.persons')
+for row in cursor:
+ print(row[0])
+cursor.close()
+```
+
+### Cursors Support
+- `fetchone()`
+- `fetchmany()`
+- `fetchall()`
+
+```python
+from hivejdbc import connect
+conn = connect('example.com', database='default')
+cursor = conn.cursor()
+cursor.execute('select * from test.persons')
+cursor.fetchone() # fetch first row or None
+cursor.fetchmany(5) # fetch next 5 rows
+cursor.fetchall() # fetch remaining rows or empty list
+cursor.close()
+```
+
+## Connection Strings
+`hivejdbc` features many `connect` function arguments. Many of these arguments can be ignored
+and are simply present to offer the full options provided by the **Hive** jdbc driver.
+
+To import the `hivejdbc` connect function:
+```python
+from hivejdbc import connect
+```
+
+### Unsecured Hive Instance
+to connect to an unsecured hive instance listening on the default port `10000`, and the `default` database:
+```python
+conn = connect('example.com', 'default')
+```
+
+unless all required `hive-jars` are on the classpath already you'll need to define the driver path
+Java uses `jar` files to combine many libraries into one. We'll use our `fatjar` to provide all the required
+dependencies in one place.
+Make sure you're using the correct driver for your **Hive** version.
+```python
+conn = connect('example.com', 'default', driver='hive-client-hive-2.1.1-hdfs-3.0.3-fatjar.jar')
+```
+
+to connect with a custom port of `10015`
+```python
+conn = connect('example.com', 'default', port=10015)
+```
+
+### Username and Password
+```python
+conn = connect(host='example.com',
+ database='default',
+ port=10015,
+ user='hive_user',
+ password='secret')
+```
+
+### SSL
+If the hive-server has `ssl` enabled you'll need to provide a `jks` trust store that contains the servers public
+certificate.
+```python
+conn = connect(host='hive2.example.com',
+ port=10015,
+ database='default',
+ driver='hive-client-hive-2.1.1-hdfs-3.0.3-fatjar.jar',
+ ssl=True,
+ trust_store='./truststore.jks',
+ trust_password='changeit',
+ principal='hive/hive2.example.com@EXAMPLE.COM',
+ user_principal='hive/hive2.example.com',
+ user_keytab='hive.keytab',
+ realm='EXAMPLE.COM',
+ kdc='kerberosdc.example.com:88')
+```
+
+### Kerberos
+Authenticating with kerberos can be done a few ways:
+1. get valid kerberos credentials via `kinit` before running `hivejdbc`
+1. rely on `hivejdbc` to obtain kerberos credentials via a `user-principal` and `user-keytab` provided
+ to the program.
+
+
+#### Operating System `kinit`
+Connect to...
+- a `ssl` enabled cluster
+- a secured cluster (`kerberos`)
+- using the operating systems kerberos configuration
+ default locations are searched depending on platform
+- using the operating system `kinit` token
+ default locations for the `token-cache` are searched
+- if `kinit` has not been performed, or a `token-cache` cannot be found an exception will be thrown
+```python
+conn = connect(host='hive2.example.com',
+ port=10015,
+ database='default',
+ driver='hive-client-hive-2.1.1-hdfs-3.0.3-fatjar.jar',
+ ssl=True,
+ trust_store='./truststore.jks',
+ trust_password='changeit',
+ principal='hive/hive2.example.com@EXAMPLE.COM')
+```
+
+#### `hivejdbc` does the `kinit` via `keytab` and a custom `krb5.conf`
+connect to...
+- a `ssl` enabled cluster
+- a secured cluster (`kerberos`)
+- using the operating systems kerberos configuration krb5.conf
+- using a `keytab` for authentication
+ the keytab will be used to login via java's built-in kerberos implementation
+ avoiding the need for any operating system dependency
+- we will provide the `kdc` and `realm` via the `krb5_conf` argument
+ if we didn't provide `krb5_conf` argument default locations would be searched within various system paths
+```python
+conn = connect(host='hive2.example.com',
+ port=10015,
+ database='default',
+ driver='hive-client-hive-2.1.1-hdfs-3.0.3-fatjar.jar',
+ ssl=True,
+ trust_store='./truststore.jks',
+ trust_password='changeit',
+ principal='hive/hive2.example.com@EXAMPLE.COM',
+ krb5_conf='kerberos/custom_krb5.conf',
+ user_principal='hive/hive2.example.com',
+ user_keytab='user.keytab')
+```
+
+
+
+#### `hivejdbc` does the `kinit` via `keytab` with no `krb5.conf`
+connect to...
+- an ssl enabled cluster
+- a secured cluster (kerberos)
+- not using the operating system or relying on any of its configurations
+- manually setting the realm, and the kerberos "kdc" to authenticate to
+- using a keytab for authentication
+- this configuration is the most portable...
+```python
+conn = connect(host='hive2.example.com',
+ port=10015,
+ database='default',
+ driver='hive-client-hive-2.1.1-hdfs-3.0.3-fatjar.jar',
+ ssl=True,
+ trust_store='./truststore.jks',
+ trust_password='changeit',
+ principal='hive/hive2.example.com@EXAMPLE.COM',
+ user_principal='hive/hive2.example.com',
+ user_keytab='hive.keytab',
+ realm='EXAMPLE.COM',
+ kdc='kerberosdc.example.com:88')
+```
+
+## Queries and Parameters
+
+For these examples we'll setup a `test` database with a `persons` table...
+
+```python
+cursor = conn.cursor()
+cursor.execute('CREATE DATABASE IF NOT EXISTS test')
+cursor.execute('DROP TABLE IF EXISTS test.persons')
+cursor.execute('CREATE TABLE test.persons (name VARCHAR(64), age INT, address STRING, '
+ 'first TIMESTAMP, balance DECIMAL(12,2))')
+```
+
+Our table sql will have 5 columns defined in the above statement:
+```sql
+CREATE TABLE test.persons (
+ name VARCHAR(64),
+ age INT,
+ address STRING,
+ first TIMESTAMP,
+ balance DECIMAL(12,2)
+)
+```
+
+### single insert
+Let's insert a single record:
+```python
+cursor.execute('''
+INSERT INTO TABLE test.persons (name, age, address, first, balance)
+VALUES ('john doe', 35, '1583 Whistling Pines Dr, Redstone CO 80612', '08-22-1981 00:00:00', '100.10')
+''')
+```
+
+### `positional` parameterized sql query
+Insert a single record, using paramterized arguments that will automatically be escaped.
+This prevents sql injection as well
+
+```python
+cursor.execute('''
+INSERT INTO TABLE test.persons (name, age, address, first, balance)
+VALUES (%s, %s, %s, %s, %s)
+''', ['Kevin Jones', 28, '802 1st st, Raleigh NC', '12-23-2020 00:00:00', 85.25])
+```
+
+The signature of `execute` is:
+```python
+def execute(sql, params=None):
+ ""
+```
+- **sql** is the sql statement
+- **params** are `named (dict)` or `positional (sequence)` arguments used by the sql statement for variable
+ substitution
+
+### `named` parameterized sql query
+**INSERT** with named parameters
+
+In addition to positional parameters using `%s` we support `named parameters` as well.
+
+You can see the named arguments are defined below in the `sql` statement as: `(:name, :age, :addr, :dt, :bal)`
+
+The second parameter to the `execute` method is a `dictionary` where the keys are equal to the parameters defined in the sql
+```python
+cursor.execute('''
+INSERT INTO TABLE test.persons (name, age, address, first, balance)
+VALUES (:name, :age, :addr, :dt, :bal)
+''', {'name': 'Bob Clark',
+ 'age': 41,
+ 'addr': '348 W Dickinson Rd, Norfolk VA',
+ 'dt': '12-23-2020 00:00:00',
+ 'bal': 200.20})
+```
+
+### Using `executemany`
+You can execute many queries in one python statement using `executemany`
+
+Note that this is for programmer ease of use; hive's `jdbc` driver does not support `batch-mode`, so this functionality is faked and is no more
+efficient than executing 3 statements individually.
+```
+cursor.executemany('''
+INSERT INTO TABLE test.persons (name, age, address, first, balance)
+VALUES (%s, %s, %s, %s, %s)
+''', [
+ ('john doe', 35, '1583 Whistling Pines Dr, Redstone CO 80612', '08-22-1981 00:00:00', 100.10),
+ ('Kevin Jones', 28, '802 1st st, Raleigh NC', '12-23-2020 00:00:00', 85.25),
+ ('Bob Clark', 41, '348 W Dickinson Rd, Norfolk VA', '12-23-2020 00:00:00', 200.20)
+])
+```
+
+
+
+
+%package -n python3-hivejdbc
+Summary: Hive database driver via jdbc
+Provides: python-hivejdbc
+BuildRequires: python3-devel
+BuildRequires: python3-setuptools
+BuildRequires: python3-pip
+%description -n python3-hivejdbc
+# hivejdbc
+hivejdbc is `db-api-2.0` compliant **Apache Hive** driver that supports
+- kerberos
+- ssl
+- service discovery via zookeeper
+- host-connection list
+- and all other jdbc driver options
+
+# installation
+```properties
+pip3 install hivejdbc
+```
+
+## Cursors
+`hivejdbc` can use a `dictonary` cursor if desired.
+
+```python
+from hivejdbc import connect, DictCursor
+conn = connect('example.com', 'default', cursor=DictCursor)
+
+```
+
+### Cursors support `with`
+```python
+from hivejdbc import connect
+conn = connect('example.com', database='default')
+with conn.cursor() as cursor:
+ cursor.execute('select * from test.persons')
+ rows = cursor.fetchall()
+```
+
+### Cursors are iterable
+```python
+from hivejdbc import connect
+conn = connect('example.com', database='default')
+cursor = conn.cursor()
+cursor.execute('select * from test.persons')
+for row in cursor:
+ print(row[0])
+cursor.close()
+```
+
+### Cursors Support
+- `fetchone()`
+- `fetchmany()`
+- `fetchall()`
+
+```python
+from hivejdbc import connect
+conn = connect('example.com', database='default')
+cursor = conn.cursor()
+cursor.execute('select * from test.persons')
+cursor.fetchone() # fetch first row or None
+cursor.fetchmany(5) # fetch next 5 rows
+cursor.fetchall() # fetch remaining rows or empty list
+cursor.close()
+```
+
+## Connection Strings
+`hivejdbc` features many `connect` function arguments. Many of these arguments can be ignored
+and are simply present to offer the full options provided by the **Hive** jdbc driver.
+
+To import the `hivejdbc` connect function:
+```python
+from hivejdbc import connect
+```
+
+### Unsecured Hive Instance
+to connect to an unsecured hive instance listening on the default port `10000`, and the `default` database:
+```python
+conn = connect('example.com', 'default')
+```
+
+unless all required `hive-jars` are on the classpath already you'll need to define the driver path
+Java uses `jar` files to combine many libraries into one. We'll use our `fatjar` to provide all the required
+dependencies in one place.
+Make sure you're using the correct driver for your **Hive** version.
+```python
+conn = connect('example.com', 'default', driver='hive-client-hive-2.1.1-hdfs-3.0.3-fatjar.jar')
+```
+
+to connect with a custom port of `10015`
+```python
+conn = connect('example.com', 'default', port=10015)
+```
+
+### Username and Password
+```python
+conn = connect(host='example.com',
+ database='default',
+ port=10015,
+ user='hive_user',
+ password='secret')
+```
+
+### SSL
+If the hive-server has `ssl` enabled you'll need to provide a `jks` trust store that contains the servers public
+certificate.
+```python
+conn = connect(host='hive2.example.com',
+ port=10015,
+ database='default',
+ driver='hive-client-hive-2.1.1-hdfs-3.0.3-fatjar.jar',
+ ssl=True,
+ trust_store='./truststore.jks',
+ trust_password='changeit',
+ principal='hive/hive2.example.com@EXAMPLE.COM',
+ user_principal='hive/hive2.example.com',
+ user_keytab='hive.keytab',
+ realm='EXAMPLE.COM',
+ kdc='kerberosdc.example.com:88')
+```
+
+### Kerberos
+Authenticating with kerberos can be done a few ways:
+1. get valid kerberos credentials via `kinit` before running `hivejdbc`
+1. rely on `hivejdbc` to obtain kerberos credentials via a `user-principal` and `user-keytab` provided
+ to the program.
+
+
+#### Operating System `kinit`
+Connect to...
+- a `ssl` enabled cluster
+- a secured cluster (`kerberos`)
+- using the operating systems kerberos configuration
+ default locations are searched depending on platform
+- using the operating system `kinit` token
+ default locations for the `token-cache` are searched
+- if `kinit` has not been performed, or a `token-cache` cannot be found an exception will be thrown
+```python
+conn = connect(host='hive2.example.com',
+ port=10015,
+ database='default',
+ driver='hive-client-hive-2.1.1-hdfs-3.0.3-fatjar.jar',
+ ssl=True,
+ trust_store='./truststore.jks',
+ trust_password='changeit',
+ principal='hive/hive2.example.com@EXAMPLE.COM')
+```
+
+#### `hivejdbc` does the `kinit` via `keytab` and a custom `krb5.conf`
+connect to...
+- a `ssl` enabled cluster
+- a secured cluster (`kerberos`)
+- using the operating systems kerberos configuration krb5.conf
+- using a `keytab` for authentication
+ the keytab will be used to login via java's built-in kerberos implementation
+ avoiding the need for any operating system dependency
+- we will provide the `kdc` and `realm` via the `krb5_conf` argument
+ if we didn't provide `krb5_conf` argument default locations would be searched within various system paths
+```python
+conn = connect(host='hive2.example.com',
+ port=10015,
+ database='default',
+ driver='hive-client-hive-2.1.1-hdfs-3.0.3-fatjar.jar',
+ ssl=True,
+ trust_store='./truststore.jks',
+ trust_password='changeit',
+ principal='hive/hive2.example.com@EXAMPLE.COM',
+ krb5_conf='kerberos/custom_krb5.conf',
+ user_principal='hive/hive2.example.com',
+ user_keytab='user.keytab')
+```
+
+
+
+#### `hivejdbc` does the `kinit` via `keytab` with no `krb5.conf`
+connect to...
+- an ssl enabled cluster
+- a secured cluster (kerberos)
+- not using the operating system or relying on any of its configurations
+- manually setting the realm, and the kerberos "kdc" to authenticate to
+- using a keytab for authentication
+- this configuration is the most portable...
+```python
+conn = connect(host='hive2.example.com',
+ port=10015,
+ database='default',
+ driver='hive-client-hive-2.1.1-hdfs-3.0.3-fatjar.jar',
+ ssl=True,
+ trust_store='./truststore.jks',
+ trust_password='changeit',
+ principal='hive/hive2.example.com@EXAMPLE.COM',
+ user_principal='hive/hive2.example.com',
+ user_keytab='hive.keytab',
+ realm='EXAMPLE.COM',
+ kdc='kerberosdc.example.com:88')
+```
+
+## Queries and Parameters
+
+For these examples we'll setup a `test` database with a `persons` table...
+
+```python
+cursor = conn.cursor()
+cursor.execute('CREATE DATABASE IF NOT EXISTS test')
+cursor.execute('DROP TABLE IF EXISTS test.persons')
+cursor.execute('CREATE TABLE test.persons (name VARCHAR(64), age INT, address STRING, '
+ 'first TIMESTAMP, balance DECIMAL(12,2))')
+```
+
+Our table sql will have 5 columns defined in the above statement:
+```sql
+CREATE TABLE test.persons (
+ name VARCHAR(64),
+ age INT,
+ address STRING,
+ first TIMESTAMP,
+ balance DECIMAL(12,2)
+)
+```
+
+### single insert
+Let's insert a single record:
+```python
+cursor.execute('''
+INSERT INTO TABLE test.persons (name, age, address, first, balance)
+VALUES ('john doe', 35, '1583 Whistling Pines Dr, Redstone CO 80612', '08-22-1981 00:00:00', '100.10')
+''')
+```
+
+### `positional` parameterized sql query
+Insert a single record, using paramterized arguments that will automatically be escaped.
+This prevents sql injection as well
+
+```python
+cursor.execute('''
+INSERT INTO TABLE test.persons (name, age, address, first, balance)
+VALUES (%s, %s, %s, %s, %s)
+''', ['Kevin Jones', 28, '802 1st st, Raleigh NC', '12-23-2020 00:00:00', 85.25])
+```
+
+The signature of `execute` is:
+```python
+def execute(sql, params=None):
+ ""
+```
+- **sql** is the sql statement
+- **params** are `named (dict)` or `positional (sequence)` arguments used by the sql statement for variable
+ substitution
+
+### `named` parameterized sql query
+**INSERT** with named parameters
+
+In addition to positional parameters using `%s` we support `named parameters` as well.
+
+You can see the named arguments are defined below in the `sql` statement as: `(:name, :age, :addr, :dt, :bal)`
+
+The second parameter to the `execute` method is a `dictionary` where the keys are equal to the parameters defined in the sql
+```python
+cursor.execute('''
+INSERT INTO TABLE test.persons (name, age, address, first, balance)
+VALUES (:name, :age, :addr, :dt, :bal)
+''', {'name': 'Bob Clark',
+ 'age': 41,
+ 'addr': '348 W Dickinson Rd, Norfolk VA',
+ 'dt': '12-23-2020 00:00:00',
+ 'bal': 200.20})
+```
+
+### Using `executemany`
+You can execute many queries in one python statement using `executemany`
+
+Note that this is for programmer ease of use; hive's `jdbc` driver does not support `batch-mode`, so this functionality is faked and is no more
+efficient than executing 3 statements individually.
+```
+cursor.executemany('''
+INSERT INTO TABLE test.persons (name, age, address, first, balance)
+VALUES (%s, %s, %s, %s, %s)
+''', [
+ ('john doe', 35, '1583 Whistling Pines Dr, Redstone CO 80612', '08-22-1981 00:00:00', 100.10),
+ ('Kevin Jones', 28, '802 1st st, Raleigh NC', '12-23-2020 00:00:00', 85.25),
+ ('Bob Clark', 41, '348 W Dickinson Rd, Norfolk VA', '12-23-2020 00:00:00', 200.20)
+])
+```
+
+
+
+
+%package help
+Summary: Development documents and examples for hivejdbc
+Provides: python3-hivejdbc-doc
+%description help
+# hivejdbc
+hivejdbc is `db-api-2.0` compliant **Apache Hive** driver that supports
+- kerberos
+- ssl
+- service discovery via zookeeper
+- host-connection list
+- and all other jdbc driver options
+
+# installation
+```properties
+pip3 install hivejdbc
+```
+
+## Cursors
+`hivejdbc` can use a `dictonary` cursor if desired.
+
+```python
+from hivejdbc import connect, DictCursor
+conn = connect('example.com', 'default', cursor=DictCursor)
+
+```
+
+### Cursors support `with`
+```python
+from hivejdbc import connect
+conn = connect('example.com', database='default')
+with conn.cursor() as cursor:
+ cursor.execute('select * from test.persons')
+ rows = cursor.fetchall()
+```
+
+### Cursors are iterable
+```python
+from hivejdbc import connect
+conn = connect('example.com', database='default')
+cursor = conn.cursor()
+cursor.execute('select * from test.persons')
+for row in cursor:
+ print(row[0])
+cursor.close()
+```
+
+### Cursors Support
+- `fetchone()`
+- `fetchmany()`
+- `fetchall()`
+
+```python
+from hivejdbc import connect
+conn = connect('example.com', database='default')
+cursor = conn.cursor()
+cursor.execute('select * from test.persons')
+cursor.fetchone() # fetch first row or None
+cursor.fetchmany(5) # fetch next 5 rows
+cursor.fetchall() # fetch remaining rows or empty list
+cursor.close()
+```
+
+## Connection Strings
+`hivejdbc` features many `connect` function arguments. Many of these arguments can be ignored
+and are simply present to offer the full options provided by the **Hive** jdbc driver.
+
+To import the `hivejdbc` connect function:
+```python
+from hivejdbc import connect
+```
+
+### Unsecured Hive Instance
+to connect to an unsecured hive instance listening on the default port `10000`, and the `default` database:
+```python
+conn = connect('example.com', 'default')
+```
+
+unless all required `hive-jars` are on the classpath already you'll need to define the driver path
+Java uses `jar` files to combine many libraries into one. We'll use our `fatjar` to provide all the required
+dependencies in one place.
+Make sure you're using the correct driver for your **Hive** version.
+```python
+conn = connect('example.com', 'default', driver='hive-client-hive-2.1.1-hdfs-3.0.3-fatjar.jar')
+```
+
+to connect with a custom port of `10015`
+```python
+conn = connect('example.com', 'default', port=10015)
+```
+
+### Username and Password
+```python
+conn = connect(host='example.com',
+ database='default',
+ port=10015,
+ user='hive_user',
+ password='secret')
+```
+
+### SSL
+If the hive-server has `ssl` enabled you'll need to provide a `jks` trust store that contains the servers public
+certificate.
+```python
+conn = connect(host='hive2.example.com',
+ port=10015,
+ database='default',
+ driver='hive-client-hive-2.1.1-hdfs-3.0.3-fatjar.jar',
+ ssl=True,
+ trust_store='./truststore.jks',
+ trust_password='changeit',
+ principal='hive/hive2.example.com@EXAMPLE.COM',
+ user_principal='hive/hive2.example.com',
+ user_keytab='hive.keytab',
+ realm='EXAMPLE.COM',
+ kdc='kerberosdc.example.com:88')
+```
+
+### Kerberos
+Authenticating with kerberos can be done a few ways:
+1. get valid kerberos credentials via `kinit` before running `hivejdbc`
+1. rely on `hivejdbc` to obtain kerberos credentials via a `user-principal` and `user-keytab` provided
+ to the program.
+
+
+#### Operating System `kinit`
+Connect to...
+- a `ssl` enabled cluster
+- a secured cluster (`kerberos`)
+- using the operating systems kerberos configuration
+ default locations are searched depending on platform
+- using the operating system `kinit` token
+ default locations for the `token-cache` are searched
+- if `kinit` has not been performed, or a `token-cache` cannot be found an exception will be thrown
+```python
+conn = connect(host='hive2.example.com',
+ port=10015,
+ database='default',
+ driver='hive-client-hive-2.1.1-hdfs-3.0.3-fatjar.jar',
+ ssl=True,
+ trust_store='./truststore.jks',
+ trust_password='changeit',
+ principal='hive/hive2.example.com@EXAMPLE.COM')
+```
+
+#### `hivejdbc` does the `kinit` via `keytab` and a custom `krb5.conf`
+connect to...
+- a `ssl` enabled cluster
+- a secured cluster (`kerberos`)
+- using the operating systems kerberos configuration krb5.conf
+- using a `keytab` for authentication
+ the keytab will be used to login via java's built-in kerberos implementation
+ avoiding the need for any operating system dependency
+- we will provide the `kdc` and `realm` via the `krb5_conf` argument
+ if we didn't provide `krb5_conf` argument default locations would be searched within various system paths
+```python
+conn = connect(host='hive2.example.com',
+ port=10015,
+ database='default',
+ driver='hive-client-hive-2.1.1-hdfs-3.0.3-fatjar.jar',
+ ssl=True,
+ trust_store='./truststore.jks',
+ trust_password='changeit',
+ principal='hive/hive2.example.com@EXAMPLE.COM',
+ krb5_conf='kerberos/custom_krb5.conf',
+ user_principal='hive/hive2.example.com',
+ user_keytab='user.keytab')
+```
+
+
+
+#### `hivejdbc` does the `kinit` via `keytab` with no `krb5.conf`
+connect to...
+- an ssl enabled cluster
+- a secured cluster (kerberos)
+- not using the operating system or relying on any of its configurations
+- manually setting the realm, and the kerberos "kdc" to authenticate to
+- using a keytab for authentication
+- this configuration is the most portable...
+```python
+conn = connect(host='hive2.example.com',
+ port=10015,
+ database='default',
+ driver='hive-client-hive-2.1.1-hdfs-3.0.3-fatjar.jar',
+ ssl=True,
+ trust_store='./truststore.jks',
+ trust_password='changeit',
+ principal='hive/hive2.example.com@EXAMPLE.COM',
+ user_principal='hive/hive2.example.com',
+ user_keytab='hive.keytab',
+ realm='EXAMPLE.COM',
+ kdc='kerberosdc.example.com:88')
+```
+
+## Queries and Parameters
+
+For these examples we'll setup a `test` database with a `persons` table...
+
+```python
+cursor = conn.cursor()
+cursor.execute('CREATE DATABASE IF NOT EXISTS test')
+cursor.execute('DROP TABLE IF EXISTS test.persons')
+cursor.execute('CREATE TABLE test.persons (name VARCHAR(64), age INT, address STRING, '
+ 'first TIMESTAMP, balance DECIMAL(12,2))')
+```
+
+Our table sql will have 5 columns defined in the above statement:
+```sql
+CREATE TABLE test.persons (
+ name VARCHAR(64),
+ age INT,
+ address STRING,
+ first TIMESTAMP,
+ balance DECIMAL(12,2)
+)
+```
+
+### single insert
+Let's insert a single record:
+```python
+cursor.execute('''
+INSERT INTO TABLE test.persons (name, age, address, first, balance)
+VALUES ('john doe', 35, '1583 Whistling Pines Dr, Redstone CO 80612', '08-22-1981 00:00:00', '100.10')
+''')
+```
+
+### `positional` parameterized sql query
+Insert a single record, using paramterized arguments that will automatically be escaped.
+This prevents sql injection as well
+
+```python
+cursor.execute('''
+INSERT INTO TABLE test.persons (name, age, address, first, balance)
+VALUES (%s, %s, %s, %s, %s)
+''', ['Kevin Jones', 28, '802 1st st, Raleigh NC', '12-23-2020 00:00:00', 85.25])
+```
+
+The signature of `execute` is:
+```python
+def execute(sql, params=None):
+ ""
+```
+- **sql** is the sql statement
+- **params** are `named (dict)` or `positional (sequence)` arguments used by the sql statement for variable
+ substitution
+
+### `named` parameterized sql query
+**INSERT** with named parameters
+
+In addition to positional parameters using `%s` we support `named parameters` as well.
+
+You can see the named arguments are defined below in the `sql` statement as: `(:name, :age, :addr, :dt, :bal)`
+
+The second parameter to the `execute` method is a `dictionary` where the keys are equal to the parameters defined in the sql
+```python
+cursor.execute('''
+INSERT INTO TABLE test.persons (name, age, address, first, balance)
+VALUES (:name, :age, :addr, :dt, :bal)
+''', {'name': 'Bob Clark',
+ 'age': 41,
+ 'addr': '348 W Dickinson Rd, Norfolk VA',
+ 'dt': '12-23-2020 00:00:00',
+ 'bal': 200.20})
+```
+
+### Using `executemany`
+You can execute many queries in one python statement using `executemany`
+
+Note that this is for programmer ease of use; hive's `jdbc` driver does not support `batch-mode`, so this functionality is faked and is no more
+efficient than executing 3 statements individually.
+```
+cursor.executemany('''
+INSERT INTO TABLE test.persons (name, age, address, first, balance)
+VALUES (%s, %s, %s, %s, %s)
+''', [
+ ('john doe', 35, '1583 Whistling Pines Dr, Redstone CO 80612', '08-22-1981 00:00:00', 100.10),
+ ('Kevin Jones', 28, '802 1st st, Raleigh NC', '12-23-2020 00:00:00', 85.25),
+ ('Bob Clark', 41, '348 W Dickinson Rd, Norfolk VA', '12-23-2020 00:00:00', 200.20)
+])
+```
+
+
+
+
+%prep
+%autosetup -n hivejdbc-0.2.3
+
+%build
+%py3_build
+
+%install
+%py3_install
+install -d -m755 %{buildroot}/%{_pkgdocdir}
+if [ -d doc ]; then cp -arf doc %{buildroot}/%{_pkgdocdir}; fi
+if [ -d docs ]; then cp -arf docs %{buildroot}/%{_pkgdocdir}; fi
+if [ -d example ]; then cp -arf example %{buildroot}/%{_pkgdocdir}; fi
+if [ -d examples ]; then cp -arf examples %{buildroot}/%{_pkgdocdir}; fi
+pushd %{buildroot}
+if [ -d usr/lib ]; then
+ find usr/lib -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/lib64 ]; then
+ find usr/lib64 -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/bin ]; then
+ find usr/bin -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+if [ -d usr/sbin ]; then
+ find usr/sbin -type f -printf "/%h/%f\n" >> filelist.lst
+fi
+touch doclist.lst
+if [ -d usr/share/man ]; then
+ find usr/share/man -type f -printf "/%h/%f.gz\n" >> doclist.lst
+fi
+popd
+mv %{buildroot}/filelist.lst .
+mv %{buildroot}/doclist.lst .
+
+%files -n python3-hivejdbc -f filelist.lst
+%dir %{python3_sitelib}/*
+
+%files help -f doclist.lst
+%{_docdir}/*
+
+%changelog
+* Wed Apr 12 2023 Python_Bot <Python_Bot@openeuler.org> - 0.2.3-1
+- Package Spec generated
generated by cgit v1.2.3 (git 2.25.1) at 2025-12-17 20:34:15 +0000