Last active
September 28, 2018 05:15
-
-
Save SimonGoring/4841d4ff9171e1082e605c5718008c29 to your computer and use it in GitHub Desktop.
A script to build the database from the raw files.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| """ Import libraries and create the connection. If the connection fails check the JSON file. """ | |
| import json | |
| import csv | |
| import re | |
| import psycopg2 | |
| # Set to True if we want to delete the whole database as it runs: | |
| dropall = True | |
| # Connect to the AWS database and pass in parameters using a dict that contains | |
| # parameters in the same order as requested by `connect` | |
| with open('awsconnect.json') as f: | |
| data = json.load(f) | |
| conn = psycopg2.connect(**data) | |
| cur = conn.cursor() | |
| # If we're removing all the tables: | |
| if dropall: | |
| cur.execute(""" | |
| SELECT table_name FROM information_schema.tables | |
| WHERE table_schema = 'onlineactivity' | |
| """) | |
| dbtables = [r[0] for r in cur.fetchall()] | |
| print(dbtables) | |
| for tab in dbtables: | |
| query = "DROP TABLE onlineactivity." + tab + " CASCADE;" | |
| cur.execute(query) | |
| # Regardless, check to see what tables exist: | |
| cur.execute(""" | |
| SELECT table_name FROM information_schema.tables | |
| WHERE table_schema = 'onlineactivity' | |
| """) | |
| # Convert the tuple returned by the DB to a list. | |
| dbtables = [r[0] for r in cur.fetchall()] | |
| files = [['./data/input/22100019.csv', 'Online Sales'], | |
| ['./data/input/27100285.csv', 'Financing Source'], | |
| ['./data/input/27100318.csv', 'Innovation']] | |
| iso_c = './data/input/iso3166codes.csv' | |
| naics = './data/input/NAICS-SCIAN-2017-Structure-V1-eng.csv' | |
| year, naics, size, code, \ | |
| financing, sales, innovation = set(), set(), set(), set(), set(), set(), set() | |
| units, scalar = [], [] | |
| # Run through each file once. They all have a common set of columns that can | |
| # be used. dinp is dataInput | |
| for dinp in files: | |
| with open(dinp[0], 'r') as setup: | |
| # First open the file and find the right header columns: | |
| inputdata = csv.reader(setup) | |
| headers = next(inputdata) | |
| # These occur only in some files. Will be length 0 if they do not occur in the file. | |
| finidx = [i for i, item in enumerate(headers) if re.search('financing', item)] | |
| saleidx = [i for i, item in enumerate(headers) if re.search('Online sales', item)] | |
| innoidx = [i for i, item in enumerate(headers) if re.search('Type of innovation', item)] | |
| yindex = [i for i, item in enumerate(headers) if re.search('REF_DATE', item)] | |
| nacindex = [i for i, item in enumerate(headers) if re.search('NAICS', item)] | |
| entidx = [i for i, item in enumerate(headers) if re.search('nterprise', item)] | |
| scidx = [i for i, item in enumerate(headers) if re.search('SCALAR_FACTOR', item)] | |
| scid_idx = [i for i, item in enumerate(headers) if re.search('SCALAR_ID', item)] | |
| uidx = [i for i, item in enumerate(headers) if re.search('UOM', item)] | |
| uid_idx = [i for i, item in enumerate(headers) if re.search('UOM_ID', item)] | |
| # Need checks for sale class ('Online sales and purchases'), | |
| # innovation ('Type of innovation') | |
| # sources of financing: 'Sources of financing' | |
| for rows in inputdata: | |
| # This deals with the fact that each data file contains different data. | |
| if finidx: | |
| financing.add(rows[finidx[0]]) | |
| if saleidx: | |
| sales.add(rows[saleidx[0]]) | |
| if innoidx: | |
| innovation.add(rows[innoidx[0]]) | |
| naics.add(rows[nacindex[0]]) | |
| year.add(rows[yindex[0]]) | |
| size.add(rows[entidx[0]]) | |
| newlist = [rows[uidx[0]], rows[uid_idx[0]]] | |
| if newlist not in units: | |
| units.append(newlist) | |
| newscalar = [rows[scidx[0]], rows[scid_idx[0]]] | |
| if newscalar not in scalar: | |
| scalar.append(newscalar) | |
| ###################### | |
| # Innovation: | |
| if 'innovation' not in dbtables: | |
| cur.execute(""" | |
| CREATE TABLE onlineactivity.innovation( | |
| innoid SERIAL PRIMARY KEY, | |
| innovation CHARACTER VARYING) | |
| """) | |
| sql = "INSERT INTO onlineactivity.innovation(innovation) VALUES (%s)" | |
| for inno in innovation: | |
| cur.execute(sql, [inno]) | |
| conn.commit() | |
| ###################### | |
| # Sale Class | |
| if 'sales' not in dbtables: | |
| cur.execute(""" | |
| CREATE TABLE onlineactivity.sales( | |
| saleid SERIAL PRIMARY KEY, | |
| saleclass CHARACTER VARYING) | |
| """) | |
| sql = "INSERT INTO onlineactivity.sales(saleclass) VALUES (%s)" | |
| for sale in sales: | |
| cur.execute(sql, [sale]) | |
| conn.commit() | |
| ###################### | |
| # Financing Class | |
| if 'finances' not in dbtables: | |
| cur.execute(""" | |
| CREATE TABLE onlineactivity.finances( | |
| finid SERIAL PRIMARY KEY, | |
| financing CHARACTER VARYING) | |
| """) | |
| sql = "INSERT INTO onlineactivity.finances(financing) VALUES (%s)" | |
| for fin in financing: | |
| cur.execute(sql, [fin]) | |
| conn.commit() | |
| ################################################################################ | |
| # We're going to add the new iso table: | |
| if 'isocountry' not in dbtables: | |
| cur.execute("\ | |
| CREATE TABLE onlineactivity.isocountry(\ | |
| name CHARACTER VARYING,\ | |
| alpha2 CHARACTER(2),\ | |
| alpha3 CHARACTER(3) PRIMARY KEY,\ | |
| countrycode INTEGER,\ | |
| iso_3166_2 CHARACTER VARYING(13),\ | |
| region CHARACTER VARYING,\ | |
| subregion CHARACTER VARYING,\ | |
| intermediateregion CHARACTER VARYING,\ | |
| regioncode INTEGER,\ | |
| subregioncode INTEGER,\ | |
| intermediateregioncode INTEGER)\ | |
| ") | |
| # This requires us to change all the values into 0, removing the escape characters. | |
| sql = """ | |
| INSERT INTO onlineactivity.isocountry VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s) | |
| """ | |
| with open('./data/input/iso3166codes.csv', 'r') as iso: | |
| inputdata = csv.reader(iso) | |
| next(inputdata) # Skip the first line. | |
| for rows in inputdata: | |
| cur.execute(sql, rows) | |
| conn.commit() | |
| ################################################################################ | |
| # We're going to add the naics table: | |
| if 'naics' not in dbtables: | |
| cur.execute(" \ | |
| CREATE TABLE onlineactivity.naics( \ | |
| nid SERIAL PRIMARY KEY, \ | |
| level INTEGER, \ | |
| hierstruct CHARACTER VARYING, \ | |
| code CHARACTER VARYING, \ | |
| title CHARACTER VARYING, \ | |
| superscript CHARACTER VARYING, \ | |
| definition CHARACTER VARYING); \ | |
| ") | |
| sql = """ | |
| INSERT INTO onlineactivity.naics(level, | |
| hierstruct, | |
| code, | |
| title, | |
| superscript, | |
| definition) | |
| VALUES(%s, %s, %s, %s, %s, %s) | |
| """ | |
| with open('./data/input/NAICS-SCIAN-2017-Structure-V1-eng.csv', 'r') as iso: | |
| inputdata = csv.reader(iso) | |
| next(inputdata) # Skip the first line. | |
| for rows in inputdata: | |
| cur.execute(sql, rows) | |
| conn.commit() | |
| ######################## | |
| # Adding the units data: | |
| if 'units' not in dbtables: | |
| sql = """ | |
| CREATE TABLE onlineactivity.units(unitid INTEGER PRIMARY KEY, | |
| units CHARACTER VARYING) | |
| """ | |
| cur.execute(sql) | |
| sql = """ | |
| INSERT INTO onlineactivity.units(units, unitid) VALUES (%s, %s) | |
| """ | |
| for unit in units: | |
| cur.execute(sql, [unit[0], unit[1]]) | |
| conn.commit() | |
| ################################### | |
| # Adding the scalar data: | |
| if "scalar" not in dbtables: | |
| sql = """ | |
| CREATE TABLE onlineactivity.scalar(scaleid SERIAL PRIMARY KEY, | |
| scalar CHARACTER VARYING, | |
| scale INTEGER) | |
| """ | |
| cur.execute(sql) | |
| sql = "INSERT INTO onlineactivity.scalar(scalar, scale) VALUES (%s, %s)" | |
| for scale in scalar: | |
| cur.execute(sql, [scale[0], scale[1]]) | |
| conn.commit() | |
| ################################## | |
| # Adding the enterprise size information: | |
| if "entsize" not in dbtables: | |
| sql = """ | |
| CREATE TABLE onlineactivity.entsize(sizeid SERIAL PRIMARY KEY, | |
| size CHARACTER VARYING) | |
| """ | |
| cur.execute(sql) | |
| sql = "INSERT INTO onlineactivity.entsize(size) VALUES (%s)" | |
| for sz in list(size): | |
| cur.execute(sql, [sz]) | |
| conn.commit() | |
| # All tables have been built. | |
| print('All reference tables have now been built.') | |
| ################################################################################ | |
| # Check to see if there are classes missing from the set of `naics` values in the | |
| # datasets, and then, figure out how to deal with them. I think in general | |
| # we will accept the naics classes, and assume there are mistaken entries in the | |
| # datasets. | |
| cur.execute("SELECT title FROM onlineactivity.naics") | |
| test = list(naics.difference([r[0] for r in cur.fetchall()])) | |
| # We see several patterns: | |
| # Several classes have '-distributors' added to the end. The classification | |
| # system includes distributors in the general class, so we'll cut that from | |
| # naics strings | |
| # Wholesale agents and brokers gets modified to 'Wholesale trade' | |
| # Petroleum and coal products manufacturing gets modified to coal "product" | |
| def naicsString(field, connect): | |
| "Translate any strange naics strings, check if they exist and then convert them" | |
| curs = connect.cursor() | |
| newfield = field | |
| if field == 'Wholesale agents and brokers': | |
| newfield = 'Wholesale trade agents and brokers' | |
| if re.match('.*wholesaler-distributors', field): | |
| newfield = re.sub('wholesaler-distributors', 'merchant wholesalers', field) | |
| if re.match('.*coal products.*', field): | |
| newfield = re.sub('coal products', 'coal product', field) | |
| if newfield == 'All surveyed industries': | |
| newfield = 'Private sector' | |
| if newfield == 'Petroleum product merchant wholesalers': | |
| newfield = 'Petroleum and petroleum products merchant wholesalers' | |
| if newfield == 'Selected chemical manufacturing subsectors': | |
| newfield = 'Chemical manufacturing' | |
| if newfield == 'Selected machinery manufacturing subsectors': | |
| newfield = 'Machinery manufacturing' | |
| if newfield == 'Motor vehicle and parts merchant wholesalers': | |
| newfield = 'Motor vehicle and motor vehicle parts and accessories merchant wholesalers' | |
| if newfield == 'Selected industry groups within professional, scientific and technical services': | |
| newfield = 'Professional, scientific and technical services' | |
| if newfield == 'Postal service and couriers and messengers': | |
| newfield = 'Postal service' | |
| curs.execute("SELECT title FROM onlineactivity.naics WHERE title LIKE %s", [newfield]) | |
| results = curs.fetchall() | |
| if results: | |
| out = newfield | |
| else: | |
| print('The field ' + field + | |
| ' could not be converted properly. Was converted to ' + newfield) | |
| out = -1 | |
| return out | |
| ################################################################################ | |
| # Build tables: | |
| # InnovationFund is '318' | |
| if 'innovationfinancing' not in dbtables: | |
| cur.execute(""" | |
| CREATE TABLE onlineactivity.innovationfinancing( | |
| year INTEGER, | |
| country CHARACTER(3) REFERENCES onlineactivity.isocountry(alpha3), | |
| innofund INTEGER REFERENCES onlineactivity.finances(finid), | |
| naics INTEGER REFERENCES onlineactivity.naics(nid), | |
| size INTEGER REFERENCES onlineactivity.entsize(sizeid), | |
| units INTEGER REFERENCES onlineactivity.units(unitid), | |
| scalar INTEGER REFERENCES onlineactivity.scalar(scaleid), | |
| values NUMERIC | |
| )""") | |
| if 'innovationtype' not in dbtables: | |
| cur.execute(""" | |
| CREATE TABLE onlineactivity.innovationtype( | |
| year INTEGER, | |
| country CHARACTER(3) REFERENCES onlineactivity.isocountry(alpha3), | |
| innotype INTEGER REFERENCES onlineactivity.innovation(innoid), | |
| naics INTEGER REFERENCES onlineactivity.naics(nid), | |
| size INTEGER REFERENCES onlineactivity.entsize(sizeid), | |
| units INTEGER REFERENCES onlineactivity.units(unitid), | |
| scalar INTEGER REFERENCES onlineactivity.scalar(scaleid), | |
| values NUMERIC | |
| )""") | |
| if 'onlinesales' not in dbtables: | |
| cur.execute(""" | |
| CREATE TABLE onlineactivity.onlinesales( | |
| year INTEGER, | |
| country CHARACTER(3) REFERENCES onlineactivity.isocountry(alpha3), | |
| naics INTEGER REFERENCES onlineactivity.naics(nid), | |
| size INTEGER REFERENCES onlineactivity.entsize(sizeid), | |
| saletype INTEGER REFERENCES onlineactivity.sales(saleid), | |
| units INTEGER REFERENCES onlineactivity.units(unitid), | |
| scalar INTEGER REFERENCES onlineactivity.scalar(scaleid), | |
| values NUMERIC | |
| )""") | |
| # Across all three files the sets of columns we want to use are the same, it's | |
| # just that the order of the columns makes a difference, so it's kind of annoying. | |
| goodcols = [0, 1, 3, 4, 5, 6, 8, 12] | |
| for dinp in files: | |
| print("Opening the " + dinp[1] + " data file. . .") | |
| with open(dinp[0], 'r') as setup: | |
| inputdata = csv.reader(setup) | |
| headers = next(inputdata) | |
| for rows in inputdata: | |
| if dinp[1] == 'Online Sales': | |
| sql = """ | |
| INSERT INTO onlineactivity.onlinesales | |
| VALUES(%s, | |
| (SELECT alpha3 FROM onlineactivity.isocountry AS iso WHERE iso.name LIKE %s), | |
| (SELECT MIN(nid) FROM onlineactivity.naics AS nc WHERE nc.title LIKE %s), | |
| (SELECT sizeid FROM onlineactivity.entsize AS sz WHERE sz.size LIKE %s), | |
| (SELECT saleid FROM onlineactivity.sales AS sls WHERE sls.saleclass LIKE %s), | |
| (SELECT unitid FROM onlineactivity.units AS unt WHERE unt.units LIKE %s), | |
| (SELECT scaleid FROM onlineactivity.scalar AS scl WHERE scl.scalar LIKE %s), | |
| %s) | |
| """ | |
| newrow = [rows[i] for i in goodcols] | |
| newrow[2] = naicsString(newrow[2], conn) | |
| if newrow[-1] == '': | |
| newrow[-1] = '0' | |
| cur.execute(sql, newrow) | |
| if dinp[1] == 'Financing Source': | |
| if rows[1] == 'Canada': | |
| sql = """ | |
| INSERT INTO onlineactivity.innovationfinancing | |
| VALUES(%s, | |
| (SELECT alpha3 FROM onlineactivity.isocountry AS iso WHERE iso.name LIKE %s), | |
| (SELECT finid FROM onlineactivity.finances AS fin WHERE fin.financing LIKE %s), | |
| (SELECT MIN(nid) FROM onlineactivity.naics AS nc WHERE nc.title LIKE %s), | |
| (SELECT sizeid FROM onlineactivity.entsize AS sz WHERE sz.size LIKE %s), | |
| (SELECT unitid FROM onlineactivity.units AS unt WHERE unt.units LIKE %s), | |
| (SELECT scaleid FROM onlineactivity.scalar AS scl WHERE scl.scalar LIKE %s), | |
| %s) | |
| """ | |
| newrow = [rows[i] for i in goodcols] | |
| newrow[3] = naicsString(newrow[3], conn) | |
| if newrow[-1] == '': | |
| newrow[-1] = '0' | |
| cur.execute(sql, newrow) | |
| if dinp[1] == 'Innovation': | |
| if rows[1] == 'Canada': | |
| sql = """ | |
| INSERT INTO onlineactivity.innovationtype | |
| VALUES(%s, | |
| (SELECT alpha3 FROM onlineactivity.isocountry AS iso WHERE iso.name LIKE %s), | |
| (SELECT innoid FROM onlineactivity.innovation AS inn WHERE inn.innovation LIKE %s), | |
| (SELECT MIN(nid) FROM onlineactivity.naics AS nc WHERE nc.title LIKE %s), | |
| (SELECT sizeid FROM onlineactivity.entsize AS sz WHERE sz.size LIKE %s), | |
| (SELECT unitid FROM onlineactivity.units AS unt WHERE unt.units LIKE %s), | |
| (SELECT scaleid FROM onlineactivity.scalar AS scl WHERE scl.scalar LIKE %s), | |
| %s) | |
| """ | |
| newrow = [rows[i] for i in goodcols] | |
| newrow[3] = naicsString(newrow[3], conn) | |
| if newrow[-1] == '': | |
| newrow[-1] = '0' | |
| cur.execute(sql, newrow) | |
| print("Finished the " + dinp[1] + " data file. Closing.") | |
| conn.commit() |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| { | |
| "cells": [ | |
| { | |
| "cell_type": "markdown", | |
| "metadata": {}, | |
| "source": [ | |
| "# SQL Queries and Connections\n", | |
| "\n", | |
| "Databases work as the back-end for a number of web services. The alow us to manage data, and to access data in a variety of ways. SQL allows us to do this by selecting, grouping and filtering data. We use programs like Python or R (or JavaScript, Go, Perl, PHP. . . ) to perform this secondary data management. In general we can think of data access in one of three ways:\n", | |
| "\n", | |
| "## Select Data\n", | |
| "\n", | |
| "`SELECT` is the fundamental command of most database applications. It provides us with the mechanism to ask questions of the database, and then to have them returned to our application. To use `SELECT` we need to know about the data we are working with. The way data is arranged into tables and the columns within those tables.\n", | |
| "\n", | |
| "## Filter Data\n", | |
| "\n", | |
| "It is rare that we ask for all of the data within a database. Often we want a subset of the table values, `WHERE` some condition (or conditions) are met. These conditions are most often connected using boolean terms, `AND`, `OR` and `NOT`.\n", | |
| "\n", | |
| "## Aggregating Data\n", | |
| "\n", | |
| "While much of our data may be related to individual transactions, or data points, we often want to group our data. If we `GROUP BY` different conditions (variable classes) we can take the grouped values and `SELECT` minimum, maximum, distinct or other aggregations.\n", | |
| "\n", | |
| "# About the Data\n", | |
| "\n", | |
| "I obtained three files from three sources:\n", | |
| "\n", | |
| "* **Innovation Financing**: Survey of advanced technology, source of financing for enterprises that had expenditures in advanced technologies between 2012 and 2014, by by North American Industry Classification System (NAICS) and enterprise size for Canada and certain provinces. [link](https://open.canada.ca/data/en/dataset/fe789633-800b-4e9e-aa5e-57b031e5a40c)\n", | |
| "* **Online Sales**: Digital technology and Internet use, online sales and purchases, by North American Industry Classification System (NAICS) and size of enterprise for Canada from 2012 to 2013. [link](https://open.canada.ca/data/en/dataset/878fea43-f315-4d68-a4fa-d1b946742da7)\n", | |
| "* **Introduction of innovations by industry and enterprise size**: Survey of advanced technology, introduction of innovations between 2012 and 2014, by type of innovation, North American Industry Classification System (NAICS) and enterprise size for Canada and certain provinces. [Link](https://open.canada.ca/data/en/dataset/989ca699-c982-4a19-8ccc-2bd15073259d).\n", | |
| "\n", | |
| "## General Schema" | |
| ] | |
| }, | |
| { | |
| "attachments": { | |
| "relationships.real.compact.png": { | |
| "image/png": "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" | |
| } | |
| }, | |
| "cell_type": "markdown", | |
| "metadata": {}, | |
| "source": [ | |
| "\n", | |
| "\n", | |
| "**Figure 1**. A schema, generated using SchemaSpy indicating the key tables and keys and foreign keys for the database." | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "metadata": {}, | |
| "source": [ | |
| "## My Questions\n", | |
| "\n", | |
| "I want to know:\n", | |
| "\n", | |
| "1. Is Innovation financing directly related to the introduction of innovation? Or is innovation in some industries more expensive? If we look at industries with a low financing to innovation ratio, can we make the argument that these industries are more efficient in innovating and thus, represent a good opportunity for investment?\n", | |
| "2. Is Innovation related to online sales? Are industries that have innovated more likely to also have a high rate of online sales?\n", | |
| "3. Which industries have innovated the most? The least? How does this relate to their rates of financing and their rates of online activity?\n", | |
| "\n", | |
| "# Working through SQL Queries\n", | |
| "\n", | |
| "## Connecting to the Database\n", | |
| "\n", | |
| "As we've seen before we need to import the `psycopg2` library, and import our connection string from a file. We have the file saved as `awsconnect.json`. To do some basic analysis we need to load the `json`, `os`, and `psycopg2` packages.\n", | |
| "\n", | |
| "After that we need to open a connection to the `awsconnect.json` file and read the data in as a dictionary from the file.\n", | |
| "\n", | |
| "Then we establish a connection with the database. The `awsconnect.json` file also contains all the information required to add a connection to your GUI as well. If you would like to use both a graphical and Python approach to managing the database, you can use the connection string to link to pgAdmin or dBeaver." | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": 15, | |
| "metadata": {}, | |
| "outputs": [], | |
| "source": [ | |
| "# Insert the code here. You need to:\n", | |
| "# 1. Import the packages\n", | |
| "# 2. Load the JSON file\n", | |
| "# 3. Create the connection\n", | |
| "import json\n", | |
| "import os\n", | |
| "import psycopg2\n", | |
| "\n", | |
| "with open('awsconnect.json') as f:\n", | |
| " data = json.load(f)\n", | |
| "conn = psycopg2.connect(**data)\n", | |
| "cur = conn.cursor()" | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "metadata": {}, | |
| "source": [ | |
| "## The First `SELECT`\n", | |
| "\n", | |
| "The database we've built contains eleven tables. Since we're interested in the kinds of innovation that industries might be undertaking, lets look at the table. We want to `SELECT` each row in the `innovation` table. If we suspect the table might be very large it is a good idea to use the `LIMIT` field to modify the query.\n", | |
| "\n", | |
| "In Python, and generally, it is often better to separate the query from the function that calls it:" | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": 2, | |
| "metadata": {}, | |
| "outputs": [ | |
| { | |
| "name": "stdout", | |
| "output_type": "stream", | |
| "text": [ | |
| "\n", | |
| " SELECT * \n", | |
| " FROM onlineactivity.innovation\n", | |
| " LIMIT 10\n", | |
| "\n" | |
| ] | |
| } | |
| ], | |
| "source": [ | |
| "sql = \"\"\"\n", | |
| " SELECT * \n", | |
| " FROM onlineactivity.innovation\n", | |
| " LIMIT 10\n", | |
| "\"\"\"\n", | |
| "print(sql)" | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "metadata": {}, | |
| "source": [ | |
| "We have already defined our `cur`sor. It is the Python object that is going to interact directly with the database through the Open DataBase Connectivity (ODBC) driver. We will execute the `sql` statement through the cursor, and then fetch the output:" | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": 3, | |
| "metadata": {}, | |
| "outputs": [ | |
| { | |
| "name": "stdout", | |
| "output_type": "stream", | |
| "text": [ | |
| "[(1, 'Marketing innovation'), (2, 'All innovation'), (3, 'Organizational innovation'), (4, 'Product innovation'), (5, 'Process innovation'), (6, 'No innovation')]\n" | |
| ] | |
| } | |
| ], | |
| "source": [ | |
| "cur.execute(sql)\n", | |
| "\n", | |
| "innoLevels = cur.fetchall()\n", | |
| "\n", | |
| "print(innoLevels)" | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "metadata": {}, | |
| "source": [ | |
| "You can see here that the `psycopg2` output is a `list` of [`tuples`](https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences). A tuple is immutable, meaning it cannot be extended or changed. This makes sense, since it is the output of the database, and so should be fixed.\n", | |
| "\n", | |
| "If we want to extract each of the actual text fields we can use a `for` loop, outputting to a list." | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": 6, | |
| "metadata": {}, | |
| "outputs": [ | |
| { | |
| "name": "stdout", | |
| "output_type": "stream", | |
| "text": [ | |
| "[[1, 'Marketing innovation'], [2, 'All innovation'], [3, 'Organizational innovation'], [4, 'Product innovation'], [5, 'Process innovation'], [6, 'No innovation']]\n" | |
| ] | |
| } | |
| ], | |
| "source": [ | |
| "levels = [list(i) for i in innoLevels]\n", | |
| "print(levels)" | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "metadata": {}, | |
| "source": [ | |
| "Here is a relatively straightforward output, we are simply listing the innovation fields. This is tied in our database to the `innovationtype` table in the `onlineactivity` schema. Since we're using an integer as a `FOREIGN KEY` when we look at the `innovationtype` table (or at least the first two rows), we can see that the actual innovation type (the third column) comes out as an integer." | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": 7, | |
| "metadata": {}, | |
| "outputs": [ | |
| { | |
| "name": "stdout", | |
| "output_type": "stream", | |
| "text": [ | |
| "[(2014, 'CAN', 2, 1, 2, 239, 1, Decimal('54.8')), (2014, 'CAN', 2, 1, 5, 239, 1, Decimal('53.5')), (2014, 'CAN', 2, 1, 6, 239, 1, Decimal('64.5')), (2014, 'CAN', 2, 1, 3, 239, 1, Decimal('78.1')), (2014, 'CAN', 2, 89, 2, 239, 1, Decimal('31.4')), (2014, 'CAN', 2, 89, 5, 239, 1, Decimal('31.6')), (2014, 'CAN', 2, 89, 6, 239, 1, Decimal('13.6')), (2014, 'CAN', 2, 89, 3, 239, 1, Decimal('0')), (2014, 'CAN', 2, 118, 2, 239, 1, Decimal('45.8')), (2014, 'CAN', 2, 118, 5, 239, 1, Decimal('42.1'))]\n" | |
| ] | |
| } | |
| ], | |
| "source": [ | |
| "sql = \"\"\"\n", | |
| " SELECT * \n", | |
| " FROM onlineactivity.innovationtype\n", | |
| " LIMIT 10\n", | |
| " \"\"\"\n", | |
| "cur.execute(sql)\n", | |
| "ittype = cur.fetchall()\n", | |
| "print(ittype)" | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "metadata": {}, | |
| "source": [ | |
| "## Joins\n", | |
| "\n", | |
| "We want to obtain text strings for the innovation types so that our results are clearer. We have two connected tables: `onlineactivity.innovationtype` and `onlineactivity.innovation`. These are linked such that the column `innotype` in `innovationtype` is linked to the column `innoid` in the `innovation` table. So, to get our output we need to `JOIN` these two tables `ON` the reported relationship." | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": 17, | |
| "metadata": {}, | |
| "outputs": [ | |
| { | |
| "name": "stdout", | |
| "output_type": "stream", | |
| "text": [ | |
| "[(2014, 'CAN', 2, 1, 2, 239, 1, Decimal('54.8'), 2, 'All innovation'), (2014, 'CAN', 2, 1, 5, 239, 1, Decimal('53.5'), 2, 'All innovation'), (2014, 'CAN', 2, 1, 6, 239, 1, Decimal('64.5'), 2, 'All innovation'), (2014, 'CAN', 2, 1, 3, 239, 1, Decimal('78.1'), 2, 'All innovation'), (2014, 'CAN', 2, 89, 2, 239, 1, Decimal('31.4'), 2, 'All innovation'), (2014, 'CAN', 2, 89, 5, 239, 1, Decimal('31.6'), 2, 'All innovation'), (2014, 'CAN', 2, 89, 6, 239, 1, Decimal('13.6'), 2, 'All innovation'), (2014, 'CAN', 2, 89, 3, 239, 1, Decimal('0'), 2, 'All innovation'), (2014, 'CAN', 2, 118, 2, 239, 1, Decimal('45.8'), 2, 'All innovation'), (2014, 'CAN', 2, 118, 5, 239, 1, Decimal('42.1'), 2, 'All innovation')]\n" | |
| ] | |
| } | |
| ], | |
| "source": [ | |
| "\n", | |
| "sql = \"\"\"\n", | |
| " SELECT * FROM\n", | |
| " onlineactivity.innovationtype AS ity\n", | |
| " JOIN onlineactivity.innovation AS inn ON ity.innotype = inn.innoid\n", | |
| " LIMIT 10\"\"\"\n", | |
| "\n", | |
| "cur.execute(sql)\n", | |
| "print(cur.fetchall())\n" | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "metadata": {}, | |
| "source": [ | |
| "So, we're getting further. It looks a bit clearer now, we can see that the first row reports data for all innovations, but what of it? What industry is this for? What else do we know? We don't need to get all the columns, we can be specific about the columns we're trying to pull:" | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": 18, | |
| "metadata": {}, | |
| "outputs": [ | |
| { | |
| "name": "stdout", | |
| "output_type": "stream", | |
| "text": [ | |
| "[(2014, 'CAN', 2, 1, 2, 239, 1, Decimal('54.8'), 'All innovation'), (2014, 'CAN', 2, 1, 5, 239, 1, Decimal('53.5'), 'All innovation'), (2014, 'CAN', 2, 1, 6, 239, 1, Decimal('64.5'), 'All innovation'), (2014, 'CAN', 2, 1, 3, 239, 1, Decimal('78.1'), 'All innovation'), (2014, 'CAN', 2, 89, 2, 239, 1, Decimal('31.4'), 'All innovation'), (2014, 'CAN', 2, 89, 5, 239, 1, Decimal('31.6'), 'All innovation'), (2014, 'CAN', 2, 89, 6, 239, 1, Decimal('13.6'), 'All innovation'), (2014, 'CAN', 2, 89, 3, 239, 1, Decimal('0'), 'All innovation'), (2014, 'CAN', 2, 118, 2, 239, 1, Decimal('45.8'), 'All innovation'), (2014, 'CAN', 2, 118, 5, 239, 1, Decimal('42.1'), 'All innovation')]\n" | |
| ] | |
| } | |
| ], | |
| "source": [ | |
| "sql = \"\"\"\n", | |
| " SELECT ity.*, inn.innovation FROM\n", | |
| " onlineactivity.innovationtype AS ity\n", | |
| " JOIN onlineactivity.innovation AS inn ON ity.innotype = inn.innoid\n", | |
| " LIMIT 10\"\"\"\n", | |
| "\n", | |
| "cur.execute(sql)\n", | |
| "print(cur.fetchall())" | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "metadata": {}, | |
| "source": [ | |
| "We've replaced the innovation foreign key with the appropriate field, but we still have the NAICS field to be replaced. This time, we need to `JOIN` on a different table. " | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": 19, | |
| "metadata": {}, | |
| "outputs": [ | |
| { | |
| "name": "stdout", | |
| "output_type": "stream", | |
| "text": [ | |
| "[(2014, 'All innovation', 'Private sector', Decimal('54.8')), (2014, 'All innovation', 'Private sector', Decimal('53.5')), (2014, 'All innovation', 'Private sector', Decimal('64.5')), (2014, 'All innovation', 'Private sector', Decimal('78.1')), (2014, 'All innovation', 'Forestry and logging', Decimal('31.4')), (2014, 'All innovation', 'Forestry and logging', Decimal('31.6')), (2014, 'All innovation', 'Forestry and logging', Decimal('13.6')), (2014, 'All innovation', 'Forestry and logging', Decimal('0')), (2014, 'All innovation', 'Mining, quarrying, and oil and gas extraction', Decimal('45.8')), (2014, 'All innovation', 'Mining, quarrying, and oil and gas extraction', Decimal('42.1'))]\n" | |
| ] | |
| } | |
| ], | |
| "source": [ | |
| "sql = \"\"\"\n", | |
| " SELECT ity.year, inn.innovation, nai.title, ity.values FROM\n", | |
| " onlineactivity.innovationtype AS ity\n", | |
| " JOIN onlineactivity.innovation AS inn ON ity.innotype = inn.innoid\n", | |
| " JOIN onlineactivity.naics AS nai ON nai.nid = ity.naics\n", | |
| " LIMIT 10\"\"\"\n", | |
| "\n", | |
| "cur.execute(sql)\n", | |
| "print(cur.fetchall())" | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "metadata": {}, | |
| "source": [ | |
| "So now we've shown that we can replace titles and names. We want to try to aggregate values now. For example, what industries generated significant innovations?\n", | |
| "\n", | |
| "# Filtering\n", | |
| "\n", | |
| "If we want to start aggregating data then we need to think about how we might go about creating a set of data that best represents our question. Our question will expand, but lets start with all data from `Small` sized companies. To do this we need to `JOIN` the `entsize` table as well:" | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": 20, | |
| "metadata": {}, | |
| "outputs": [ | |
| { | |
| "name": "stdout", | |
| "output_type": "stream", | |
| "text": [ | |
| "[(2014, 'All innovation', 'Private sector', Decimal('53.5')), (2014, 'All innovation', 'Forestry and logging', Decimal('31.6')), (2014, 'All innovation', 'Mining, quarrying, and oil and gas extraction', Decimal('42.1')), (2014, 'All innovation', 'Oil and gas extraction', Decimal('35.9')), (2014, 'All innovation', 'Mining and quarrying (except oil and gas)', Decimal('37.6')), (2014, 'All innovation', 'Support activities for mining, and oil and gas extraction', Decimal('44.9')), (2014, 'All innovation', 'Utilities', Decimal('60.8')), (2014, 'All innovation', 'Utilities', Decimal('60.8')), (2014, 'All innovation', 'Electric power generation, transmission and distribution', Decimal('66.8')), (2014, 'All innovation', 'Natural gas distribution', Decimal('60.3'))]\n" | |
| ] | |
| } | |
| ], | |
| "source": [ | |
| "sql = \"\"\"\n", | |
| " SELECT ity.year, inn.innovation, nai.title, ity.values FROM\n", | |
| " onlineactivity.innovationtype AS ity\n", | |
| " JOIN onlineactivity.innovation AS inn ON ity.innotype = inn.innoid\n", | |
| " JOIN onlineactivity.naics AS nai ON nai.nid = ity.naics\n", | |
| " JOIN onlineactivity.entsize AS siz ON siz.sizeid = ity.size\n", | |
| " WHERE siz.size LIKE 'Small%'\n", | |
| " LIMIT 10\"\"\"\n", | |
| "\n", | |
| "cur.execute(sql)\n", | |
| "print(cur.fetchall())" | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "metadata": {}, | |
| "source": [ | |
| "So we will get all of the fields (you can try it out by changing the `LIMIT`). But to limit the results we need to add the `WHERE` field:" | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": 23, | |
| "metadata": {}, | |
| "outputs": [ | |
| { | |
| "name": "stdout", | |
| "output_type": "stream", | |
| "text": [ | |
| "[53.5, 31.6, 42.1, 35.9, 37.6, 44.9, 60.8, 60.8, 66.8, 60.3]\n" | |
| ] | |
| } | |
| ], | |
| "source": [ | |
| "sql = \"\"\"\n", | |
| " SELECT ity.year, inn.innovation, nai.title, ity.values FROM\n", | |
| " onlineactivity.innovationtype AS ity\n", | |
| " JOIN onlineactivity.innovation AS inn ON ity.innotype = inn.innoid\n", | |
| " JOIN onlineactivity.naics AS nai ON nai.nid = ity.naics\n", | |
| " JOIN onlineactivity.entsize AS siz ON siz.sizeid = ity.size\n", | |
| " WHERE siz.size LIKE 'Small%'\n", | |
| " LIMIT 10\"\"\"\n", | |
| "\n", | |
| "cur.execute(sql)\n", | |
| "output = cur.fetchall()\n", | |
| "outnum = [float(i[3]) for i in output]\n", | |
| "print(outnum)" | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "metadata": {}, | |
| "source": [ | |
| "So, great. If you increase the `LIMIT` you'll see that we have two different name classes for `Small` businesses. We can fix this at some point, but it makes it important to recognize the underlying data. Regardless, we have sectors, innovation classes and size, along with the value. We've used both a strict and pattern match. Now we need to start aggregation and sorting.\n", | |
| "\n", | |
| "# Grouping Counting and Aggregating\n", | |
| "\n", | |
| "We can SELECT individual columns and get all the values from the tuples in the selected columns. We can also GROUP and then aggregate. For example, we could group everything and simply count the number of tuples:" | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": 18, | |
| "metadata": {}, | |
| "outputs": [ | |
| { | |
| "name": "stdout", | |
| "output_type": "stream", | |
| "text": [ | |
| "[(103,)]\n" | |
| ] | |
| } | |
| ], | |
| "source": [ | |
| "conn.rollback()\n", | |
| "sql = \"\"\"\n", | |
| " SELECT COUNT(*) FROM\n", | |
| " onlineactivity.innovationtype AS ity\n", | |
| " JOIN onlineactivity.innovation AS inn ON ity.innotype = inn.innoid\n", | |
| " JOIN onlineactivity.naics AS nai ON nai.nid = ity.naics\n", | |
| " JOIN onlineactivity.entsize AS siz ON siz.sizeid = ity.size\n", | |
| " WHERE siz.size LIKE 'Small%' AND inn.innovation LIKE 'All%'\n", | |
| " \"\"\"\n", | |
| "cur.execute(sql)\n", | |
| "print(cur.fetchall())" | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "metadata": {}, | |
| "source": [ | |
| "This gives us 103 records. We could look at the individual values, but it would probably be more useful to sort them first, using `ORDER BY`, either as an `ASC`ending list or a `DESC`ending list." | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": 28, | |
| "metadata": {}, | |
| "outputs": [ | |
| { | |
| "name": "stdout", | |
| "output_type": "stream", | |
| "text": [ | |
| "[('All innovation', 103), ('Marketing innovation', 103), ('No innovation', 103), ('Organizational innovation', 103), ('Process innovation', 103), ('Product innovation', 103)]\n" | |
| ] | |
| } | |
| ], | |
| "source": [ | |
| "sql = \"\"\"\n", | |
| " SELECT inn.innovation, COUNT(*) FROM\n", | |
| " onlineactivity.innovationtype AS ity\n", | |
| " JOIN onlineactivity.innovation AS inn ON ity.innotype = inn.innoid\n", | |
| " JOIN onlineactivity.naics AS nai ON nai.nid = ity.naics\n", | |
| " JOIN onlineactivity.entsize AS siz ON siz.sizeid = ity.size\n", | |
| " WHERE siz.size LIKE 'Small%'\n", | |
| " GROUP BY inn.innovation\n", | |
| " \"\"\"\n", | |
| "cur.execute(sql)\n", | |
| "print(cur.fetchall())" | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "metadata": {}, | |
| "source": [ | |
| "# Research Questions" | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "metadata": {}, | |
| "source": [ | |
| "What if we're interested with the values for only small and medium businesses? We'd have to use a `WHERE` statement, but also make a judgement about how to group the values.\n", | |
| "Which industries had the highest level of \"Production Innovation\" across all size classes?" | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": 5, | |
| "metadata": {}, | |
| "outputs": [ | |
| { | |
| "name": "stdout", | |
| "output_type": "stream", | |
| "text": [ | |
| "('Product innovation', 'Navigational, measuring, medical and control instruments manufacturing', Decimal('82.5'))\n", | |
| "('Process innovation', 'Railroad rolling stock manufacturing', Decimal('76'))\n", | |
| "('Organizational innovation', 'Railroad rolling stock manufacturing', Decimal('76'))\n", | |
| "('Product innovation', 'Computer and peripheral equipment manufacturing', Decimal('75.8'))\n", | |
| "('Product innovation', 'Computer and electronic product manufacturing', Decimal('75.4'))\n" | |
| ] | |
| } | |
| ], | |
| "source": [ | |
| "conn.rollback()\n", | |
| "sql = \"\"\"\n", | |
| " SELECT inn.innovation, nai.title, ity.values FROM\n", | |
| " onlineactivity.innovationtype AS ity\n", | |
| " JOIN onlineactivity.innovation AS inn ON ity.innotype = inn.innoid\n", | |
| " JOIN onlineactivity.naics AS nai ON nai.nid = ity.naics\n", | |
| " JOIN onlineactivity.entsize AS siz ON siz.sizeid = ity.size\n", | |
| " WHERE siz.size LIKE 'Total%' AND inn.innovation NOT LIKE 'All%'\n", | |
| " ORDER BY ity.values DESC\n", | |
| " LIMIT 5\n", | |
| " \"\"\"\n", | |
| "cur.execute(sql)\n", | |
| "for records in cur.fetchall():\n", | |
| " print(records)" | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "metadata": {}, | |
| "source": [ | |
| "And now we want the bottom 5:" | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": 21, | |
| "metadata": {}, | |
| "outputs": [ | |
| { | |
| "name": "stdout", | |
| "output_type": "stream", | |
| "text": [ | |
| "('Marketing innovation', 'Forestry and logging', Decimal('4.8'))\n", | |
| "('Marketing innovation', 'Oil and gas extraction', Decimal('8.6'))\n", | |
| "('Product innovation', 'Oil and gas extraction', Decimal('8.6'))\n", | |
| "('Product innovation', 'Forestry and logging', Decimal('10.7'))\n", | |
| "('Marketing innovation', 'Transit and ground passenger transportation', Decimal('10.9'))\n" | |
| ] | |
| } | |
| ], | |
| "source": [ | |
| "conn.rollback()\n", | |
| "sql = \"\"\"\n", | |
| " SELECT inn.innovation, nai.title, ity.values FROM\n", | |
| " onlineactivity.innovationtype AS ity\n", | |
| " JOIN onlineactivity.innovation AS inn ON ity.innotype = inn.innoid\n", | |
| " JOIN onlineactivity.naics AS nai ON nai.nid = ity.naics\n", | |
| " JOIN onlineactivity.entsize AS siz ON siz.sizeid = ity.size\n", | |
| " WHERE siz.size LIKE 'Total%' \n", | |
| " AND inn.innovation NOT LIKE 'All%'\n", | |
| " AND inn.innovation NOT LIKE 'No%'\n", | |
| " AND ity.values > 0\n", | |
| " ORDER BY ity.values ASC\n", | |
| " LIMIT 5\n", | |
| " \"\"\"\n", | |
| "cur.execute(sql)\n", | |
| "for records in cur.fetchall():\n", | |
| " print(records)" | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "metadata": {}, | |
| "source": [ | |
| "So, the problem is that we now only see tobacco manufacturing. This isn't helpful at all. We want to know something about all the industries." | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": 33, | |
| "metadata": { | |
| "scrolled": true | |
| }, | |
| "outputs": [ | |
| { | |
| "name": "stdout", | |
| "output_type": "stream", | |
| "text": [ | |
| "('Aerospace product and parts manufacturing', Decimal('55.7'))\n", | |
| "('Agricultural, construction and mining machinery manufacturing', Decimal('62.6'))\n", | |
| "('Air transportation', Decimal('34.4'))\n", | |
| "('Animal food manufacturing', Decimal('42.9'))\n", | |
| "('Architectural, engineering and related services', Decimal('38.1'))\n" | |
| ] | |
| } | |
| ], | |
| "source": [ | |
| "conn.rollback()\n", | |
| "sql = \"\"\"\n", | |
| "SELECT nai.title, MAX(ity.values) AS top FROM\n", | |
| " onlineactivity.innovationtype AS ity\n", | |
| " JOIN onlineactivity.innovation AS inn ON ity.innotype = inn.innoid\n", | |
| " JOIN onlineactivity.naics AS nai ON nai.nid = ity.naics\n", | |
| " JOIN onlineactivity.entsize AS siz ON siz.sizeid = ity.size\n", | |
| " WHERE siz.size LIKE 'Total%' \n", | |
| " AND inn.innovation NOT LIKE 'All%'\n", | |
| " AND inn.innovation NOT LIKE 'No%'\n", | |
| "GROUP BY nai.title\n", | |
| "ORDER BY nai.title\n", | |
| "\n", | |
| " LIMIT 5\n", | |
| "\"\"\"\n", | |
| "cur.execute(sql)\n", | |
| "for records in cur.fetchall():\n", | |
| " print(records)" | |
| ] | |
| }, | |
| { | |
| "cell_type": "markdown", | |
| "metadata": {}, | |
| "source": [ | |
| "So with this we can get the value, of the best performing sector, but we don't know what itis" | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": 40, | |
| "metadata": {}, | |
| "outputs": [ | |
| { | |
| "name": "stdout", | |
| "output_type": "stream", | |
| "text": [ | |
| "('Audio and video equipment manufacturing', 'Process innovation', Decimal('48'))\n", | |
| "('Audio and video equipment manufacturing', 'Product innovation', Decimal('74.1'))\n", | |
| "('Audio and video equipment manufacturing', 'All innovation', Decimal('81.7'))\n", | |
| "('Audio and video equipment manufacturing', 'Marketing innovation', Decimal('48'))\n", | |
| "('Audio and video equipment manufacturing', 'Organizational innovation', Decimal('55.6'))\n", | |
| "('Audio and video equipment manufacturing', 'No innovation', Decimal('18.3'))\n", | |
| "('Computer and electronic product manufacturing', 'All innovation', Decimal('86.4'))\n", | |
| "('Computer and electronic product manufacturing', 'Product innovation', Decimal('75.4'))\n", | |
| "('Computer and electronic product manufacturing', 'Process innovation', Decimal('57.4'))\n", | |
| "('Computer and electronic product manufacturing', 'Organizational innovation', Decimal('52.1'))\n", | |
| "('Computer and electronic product manufacturing', 'Marketing innovation', Decimal('47.6'))\n", | |
| "('Computer and electronic product manufacturing', 'No innovation', Decimal('13.6'))\n", | |
| "('Computer and peripheral equipment manufacturing', 'Process innovation', Decimal('50.2'))\n", | |
| "('Computer and peripheral equipment manufacturing', 'All innovation', Decimal('83.4'))\n", | |
| "('Computer and peripheral equipment manufacturing', 'Organizational innovation', Decimal('48.3'))\n", | |
| "('Computer and peripheral equipment manufacturing', 'Marketing innovation', Decimal('40'))\n", | |
| "('Computer and peripheral equipment manufacturing', 'No innovation', Decimal('16.6'))\n", | |
| "('Computer and peripheral equipment manufacturing', 'Product innovation', Decimal('75.8'))\n", | |
| "('Navigational, measuring, medical and control instruments manufacturing', 'No innovation', Decimal('9.9'))\n", | |
| "('Navigational, measuring, medical and control instruments manufacturing', 'Process innovation', Decimal('59.4'))\n", | |
| "('Navigational, measuring, medical and control instruments manufacturing', 'All innovation', Decimal('90.1'))\n", | |
| "('Navigational, measuring, medical and control instruments manufacturing', 'Marketing innovation', Decimal('54.3'))\n", | |
| "('Navigational, measuring, medical and control instruments manufacturing', 'Product innovation', Decimal('82.5'))\n", | |
| "('Navigational, measuring, medical and control instruments manufacturing', 'Organizational innovation', Decimal('51.5'))\n", | |
| "('Railroad rolling stock manufacturing', 'All innovation', Decimal('86'))\n", | |
| "('Railroad rolling stock manufacturing', 'Organizational innovation', Decimal('76'))\n", | |
| "('Railroad rolling stock manufacturing', 'Product innovation', Decimal('66'))\n", | |
| "('Railroad rolling stock manufacturing', 'Marketing innovation', Decimal('52'))\n", | |
| "('Railroad rolling stock manufacturing', 'Process innovation', Decimal('76'))\n", | |
| "('Railroad rolling stock manufacturing', 'No innovation', Decimal('14'))\n" | |
| ] | |
| } | |
| ], | |
| "source": [ | |
| "sql=\"\"\"\n", | |
| " WITH topfive AS (\n", | |
| " SELECT nai.title, MAX(ity.values) AS top FROM\n", | |
| " onlineactivity.innovationtype AS ity\n", | |
| " JOIN onlineactivity.innovation AS inn ON ity.innotype = inn.innoid\n", | |
| " JOIN onlineactivity.naics AS nai ON nai.nid = ity.naics\n", | |
| " JOIN onlineactivity.entsize AS siz ON siz.sizeid = ity.size\n", | |
| " WHERE siz.size LIKE 'Total%' \n", | |
| " AND inn.innovation NOT LIKE 'All%'\n", | |
| " AND inn.innovation NOT LIKE 'No%'\n", | |
| " GROUP BY nai.title\n", | |
| " ORDER BY top DESC\n", | |
| " LIMIT 5)\n", | |
| " SELECT nai.title, inn.innovation, ity.values AS top FROM\n", | |
| " onlineactivity.innovationtype AS ity\n", | |
| " JOIN onlineactivity.innovation AS inn ON ity.innotype = inn.innoid\n", | |
| " JOIN onlineactivity.naics AS nai ON nai.nid = ity.naics\n", | |
| " JOIN onlineactivity.entsize AS siz ON siz.sizeid = ity.size\n", | |
| " WHERE siz.size LIKE 'Total%' \n", | |
| " AND nai.title IN (SELECT title FROM topfive)\n", | |
| " ORDER BY nai.title\"\"\"\n", | |
| "\n", | |
| "cur.execute(sql)\n", | |
| "for record in cur.fetchall():\n", | |
| " print(record)" | |
| ] | |
| }, | |
| { | |
| "cell_type": "code", | |
| "execution_count": null, | |
| "metadata": {}, | |
| "outputs": [], | |
| "source": [] | |
| } | |
| ], | |
| "metadata": { | |
| "kernelspec": { | |
| "display_name": "Python 3", | |
| "language": "python", | |
| "name": "python3" | |
| }, | |
| "language_info": { | |
| "codemirror_mode": { | |
| "name": "ipython", | |
| "version": 3 | |
| }, | |
| "file_extension": ".py", | |
| "mimetype": "text/x-python", | |
| "name": "python", | |
| "nbconvert_exporter": "python", | |
| "pygments_lexer": "ipython3", | |
| "version": "3.6.6" | |
| } | |
| }, | |
| "nbformat": 4, | |
| "nbformat_minor": 2 | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment