Trigram uses your built-in method of indexing such as Gist or Gin. The only modification you have to make is when defining your index is specifying an operator class of “gist_trgm_ops” or “gin_trgm_ops”.

If you don’t have the contrib modules installed yet and are working in Ubuntu, from the command line enter:

# sudo apt-get install postgresql-contrib

After the contrib modules are make available, you must install pg_trgm. You do this by executing the following PostgreSQL query on the database you wish to install the module into:

CREATE EXTENSION pg_trgm;

After the pg_trgm extension has been installed, we’re ready to have some fun!

-- Create the table.
CREATE TABLE test (my_column text)
-- Create the index.
CREATE INDEX test_my_colun_trgm_idx ON test USING gist (my_column gist_trgm_ops);
-- Add a couple records
INSERT INTO test (my_Column) VALUES ('First Entry'), ('Second Entry'), ('Third Entry')
-- Query using our new index --
SELECT my_column, similarity(my_column, 'First Entry') AS similarity FROM test WHERE my_column % 'Frist Entry' ORDER BY similarity DESC

The above select statement should return all three rows with varying confidence. You’ll notice the appropriate match “First Entry” have a 1.0 confidence, which means it believes the query to be a perfect match even though the word has been mis-spelled.

Reference: http://www.postgresql.org/docs/9.0/interactive/pgtrgm.html

• http://linuxgazette.net/164/sephton.html
• http://www.postgresql.org/docs/9.1/static/textsearch.html
• http://www.slideshare.net/billkarwin/full-text-search-in-postgresql

1) Suppose we have a table named “fts” with the following schema :

• id <serial>
• body <text>
• body_tsvector <tsvector>

CREATE TABLE fts (
  id serial NOT NULL,
  body text,
  body_tsvector tsvector
)

2) Now let’s suppose the following data is present within the table:

INSERT INTO fts (body) VALUES
('An artist cannot speak about his art any more than a plant can discuss horticulture.'),
('I like work; it fascinates me. I can sit and look at it for hours.'),
('Love is a great beautifier.')

3) Next, let’s populate the body_tsvector column:

UPDATE fts SET body_tsvector = to_tsvector('english', body)

4) For speed’s sake let’s create an index on our body_tsvector column:

CREATE INDEX fts_body_tsvector_gin_idx ON fts USING GIN(body_tsvector)

5) Finally, let’s create a trigger which automatically updates or populates our body_tsvector column whenever a row is updated or inserted:

CREATE TRIGGER tsvectorupdate BEFORE INSERT OR UPDATE ON fts FOR EACH ROW EXECUTE PROCEDURE tsvector_update_trigger('body_tsvector', 'pg_catalog.english', 'body');

Now that we have a table which has been populated with data, has full text indexing set up, and will automatically update accordingly whenever a future update or insert occurs, let’s run some tests to ensure full text search works as expected.

• SELECT * FROM fts WHERE body_tsvector @@ plainto_tsquery(‘english’, ‘Discuss’)
• Should return: ID 1

• SELECT * FROM fts WHERE body_tsvector @@ plainto_tsquery(‘english’, ‘Discuss LOVE’)
• Should return: IDs 1 and 3

• SELECT * FROM fts WHERE body_tsvector @@ plainto_tsquery(‘english’, ‘Discuss’) AND NOT (body_tsvector @@ plainto_tsquery(‘english’, ‘Love’))
• Should return: ID 1

1. Create a new tSetGlobalVar object
2. Double-click the tSetGlobalVar object to open the Component tab.
3. Within the Component tab, create a new key with the value “timestamp” and set the value to: TalendDate.getDate(“yyyy-MM-dd KK.mm.ss a”) // This will create a string with a value similar to “2012-01-04 04;06;54 PM”
4. Double-click the file you wish to input/output.
5. Under “File Name”, enter somwething similar to “C:/Talend/Projects/MYProject/My File ” +  ((String)globalMap.get(“timestamp”)) + “.txt” // Obviously, replace the path, filename and file extension with whatever you’re working with. If requested, I will post some screen shots.
6. That’s it!

icial . Instead, you can use the OK + I
combination

To install the hstore contrib module, simply run this query in the database you wish to use hstore in:
CREATE EXTENSION hstore;
In these examples, we assume you have a table named “hstore_test” with a single column named “data” which is of the data type “hstore”.

Set the contents of an hstore
INSERT INTO hstore_test (data) VALUES ('"key1"=>"value1", "key2"=>"value2", "key3"=>"value3"')

Delete a key from an hstore
UPDATE hstore_test SET data = delete(data, 'key2')

Add a key/value to an hstore / replace the value of an existing key within an hstore
UPDATE hstore_test SET data = data || '"key4"=>"some value"'::hstore

Return records where hstore contains a specific key
SELECT * FROM hstore_test WHERE data ? 'key4'

Return records where hstore does not contain a specific key
SELECT * FROM hstore_test WHERE NOT data ? 'key5'

Returns records where a specific key/value are present within an hstore.
SELECT * FROM hstore_test WHERE data @> '"key4"=>"some value"'::hstore

django/projects/my_project/users/models.py
<br /> from django.db import models</p> <p>class User(models.Model):<br /> # username and password are equivalent to “character varying(64)” data type<br /> username = models.CharField(max_length = 64)<br /> password= models.CharField(max_length = 64)<br /> # bio is equivalent to “text” data type<br /> bio = models.TextField(max_length = 2000)</p> <p>class Transaction(models.Model):<br /> # Creates a foreign key relationship between this table’s “user_id”<br /> # column and the User class’s table’s “id” field.<br /> user_id = models.ForeignKey(User)<br /> # quantity equivalent to “integer” data type<br /> quantity = models.IntegerField()<br /> # amount equivalent to “numeric(7,2)” data type<br /> amount = models.DecimalField(max_digits = 7, decimal_places = 2)<br />

django/projects/my_project/users/models.py
<br /> from django.template import Context, loader<br /> from django.http import HttpResponse</p> <p>from users.models import User, Transaction</p> <p>def index(request):<br /> template = loader.get_template(‘users/index.html’)<br /> # Grab a list of all users, and order by username.<br /> # Alternately, we can order in reverse by passing “-username” instead of “username”<br /> all_users = User.objects.all().order_by(‘username’)<br /> # Grab user information based on the primary key, where its value is 1.<br /> user = User.objects.filter(pk = 1)<br /> # Grab transactions associated with a specific user.<br /> # “select_related()” does a join between transaction and user tables.<br /> transactions = Transaction.objects.filter(user_id = 1).select_related()</p> <p> context = Context({<br /> ‘all_users’: all_users,<br /> ‘user’: user,<br /> ‘transactions’: transactions,<br /> })</p> <p> response = template.render(context)<br /> return HttpResponse(response)<br />

django/templates/users/index.html
</p> <h2>Render All Users</h2> <p>{% if all_users %}</p> <ul> {% for user in all_users %}</p> <li>{{ user.username }}</li> <p> {% endfor %} </ul> <p>{% endif %}</p> <h2>Display A Single User’s Information</h2> <p>{{ user.username }}: {{ user.bio }}</p> <h2>Display Transactions Associated With The Above User</h2> <p>{% if transactions %}</p> <table> <tbody> {% for transaction in transactions %}</p> <tr> <td>{{ transaction.id }}</td> <td>${{ transaction.amount }}</td> <td>{{ transaction.user.username }}</td> <td>{{ transaction.user.bio }}</td> </tr> <p> {% endfor %}<br /> </tbody> </table> <p>{% endif %}<br />

This tutorial is for individuals who are interested in setting up a DSN entry in their Data Sources (ODBC) for PostgreSQL. We cover both 32-bit and 64-bit versions of Windows, as each must be configured slightly differently.

• Download and install the latest version of psqlODBC from: http://www.postgresql.org/ftp/odbc/versions/msi/
  • Please note: If running a 64-bit version of Windows, you will want to download and install BOTH the psqlodbc_XX_XX_XXXX.zip and psqlodbc_XX_XX_XXXX-x64.zip file. If running the 32-bit version of Windows, simply download and install psqlodbc_XX_XX_XXXX.zip.
• Un-Zip and run the MSI contained within the Zip file(s). (Should be named psqlodbc.msi or psqlodbc_x64.msi)
• If running a 32-bit version of Windows:
  • Go to Start -> Administrative Tools -> Data Sources (ODBC) (Or, go to Start -> Run and enter: %WINDIR%\System32\odbcad32.exe)
• If running a 64-bit version of Windows:
  • To run the 64-bit version of Data Sources: Go to Start -> Administrative Tools -> Data Sources (ODBC) (Or, go to Start -> Run and enter: %WINDIR%\System32\odbcad32.exe
  • To run the 32-bit version of Data Sources: Go to Start -> Run (or Press Windows+R keys) and enter %WINDIR%\SysWOW64\odbcad32.exe
  • Please note: You CANNOT have the 32-bit and 64-bit versions of odbcad32.exe running at the same time. If you attempt to run one while the other is already loaded, it will simply focus on the one already running.
• On either the User DSN (DSNs available for only that user) or System DSN (DSNs available to every user) tab, click the Add button.
• Scroll down the list and find the PostgreSQL ODBC Driver. You may select ANSI or UNICODE (For future support I personally prefer UNICODE), and click Finish.
  • Data Source refers to the programmable name of the DSN Entry. I’d recommend sticking to lower-case letters and underscores. Ex: psql_server
  • Specify the Database, Server, User Name and Password to your PostgreSQL server. Alternately, you may also enter a Description, specify a different Port, and set the SSL Mode.
  • Click the Test button to ensure everything has been specified correctly.
  • Click the Save button to create the DSN.

Some useful notes:

• If running a 64-bit version of Windows, 32-bit applications will reference ONLY the DSNs specified within the 32-bit version of Data Sources (ODBC). Likewise, 64-bit applications will only reference the DSNs specified within the 64-bit version of Data Sources (ODBC).
• If running the 32-bit version of Windows, the above mentioned problems are not applicable.
• If you are having problems Testing the connection before saving the DSN, ensure permissions are set appropriately on the PostgreSQL server’s side by taking a look at the pg_hba.conf file (Generally located at C:\program files\postgresql\9.1\data\pg_hba.conf). If the configuration file is not present within that directory, the file should be present within whatever directory was set as PostgreSQL’s “data” directory which also contains the data files as well).

	// Validate Photo
	if(!empty($_FILES['photo'])) { // Photo uploaded.
		if($_FILES['photo']['error'] != UPLOAD_ERR_OK) {
			$errors['photo'] = 'Server encountered an error while attempting to upload your Photo.';
		} else if(!is_uploaded_file($_FILES['photo']['tmp_name'])) { // File specified is local file system, not actually uploaded. BAD.
			$errors['photo'] = 'Photo specified is not valid.';
		} else { // Check if the image is valid by loading it into memory as an image.
			$image_info = @getimagesize($_FILES['photo']['tmp_name']); // Grabs the dimensions and type of image. May throw an error if not an image, not yet tested.
			$image_type = $image_info[2]; // Grab the image type.
			$image_function = False;
			if($image_type == IMAGETYPE_JPEG) {
				$image_function = 'jpeg';
			} else if($image_type == IMAGETYPE_PNG) {
				$image_function = 'png';
			} else if($image_type == IMAGETYPE_GIF) {
				$image_function = 'gif';
			} else if($image_type == IMAGETYPE_BMP) {
				$image_function = 'bmp';
			} else {
				$errors['photo'] = 'Photo uploaded does not appear to be a valid PNG, BMP, GIF or JPEG.';
			}
			if($image_function != False) { // Attempt to load the image into memory.
				$image_function = 'imagecreatefrom' . $image_function;
				$image = @$image_function($_FILES['photo']['tmp_name']); // Load the image into memory. May throw an error, su supress.
				if($image == False) { // If false, it means it was unable to load the image into memory.
					$errors['photo'] = 'Photo uploaded appears to be corrupt, unable to upload.';
				}
			}
			unset($image_info, $image_type, $image_function, $image); // Free no longer relavent memory.
		}
	}

Please note a useful alternative may be ezodf, which allows you to generate ODS (Open Document Spreadsheet) files for LibreOffice / OpenOffice. You can check them out at: http://packages.python.org/ezodf/index.html

The Simplest Example
import xlwt
workbook = xlwt.Workbook(encoding = 'ascii')
worksheet = workbook.add_sheet('My Worksheet')
worksheet.write(0, 0, label = 'Row 0, Column 0 Value')
workbook.save('Excel_Workbook.xls')


Formatting the Contents of a Cell
import xlwt
workbook = xlwt.Workbook(encoding = 'ascii')
worksheet = workbook.add_sheet('My Worksheet')
font = xlwt.Font() # Create the Font
font.name = 'Times New Roman'
font.bold = True
font.underline = True
font.italic = True
style = xlwt.XFStyle() # Create the Style
style.font = font # Apply the Font to the Style
worksheet.write(0, 0, label = 'Unformatted value')
worksheet.write(1, 0, label = 'Formatted value', style) # Apply the Style to the Cell
workbook.save('Excel_Workbook.xls')


Attributes of the Font Object
font.bold = True # May be: True, False
font.italic = True # May be: True, False
font.struck_out = True # May be: True, False
font.underline = xlwt.Font.UNDERLINE_SINGLE # May be: UNDERLINE_NONE, UNDERLINE_SINGLE, UNDERLINE_SINGLE_ACC, UNDERLINE_DOUBLE, UNDERLINE_DOUBLE_ACC
font.escapement = xlwt.Font.ESCAPEMENT_SUPERSCRIPT # May be: ESCAPEMENT_NONE, ESCAPEMENT_SUPERSCRIPT, ESCAPEMENT_SUBSCRIPT
font.family = xlwt.Font.FAMILY_ROMAN # May be: FAMILY_NONE, FAMILY_ROMAN, FAMILY_SWISS, FAMILY_MODERN, FAMILY_SCRIPT, FAMILY_DECORATIVE
font.charset = xlwt.Font.CHARSET_ANSI_LATIN # May be: CHARSET_ANSI_LATIN, CHARSET_SYS_DEFAULT, CHARSET_SYMBOL, CHARSET_APPLE_ROMAN, CHARSET_ANSI_JAP_SHIFT_JIS, CHARSET_ANSI_KOR_HANGUL, CHARSET_ANSI_KOR_JOHAB, CHARSET_ANSI_CHINESE_GBK, CHARSET_ANSI_CHINESE_BIG5, CHARSET_ANSI_GREEK, CHARSET_ANSI_TURKISH, CHARSET_ANSI_VIETNAMESE, CHARSET_ANSI_HEBREW, CHARSET_ANSI_ARABIC, CHARSET_ANSI_BALTIC, CHARSET_ANSI_CYRILLIC, CHARSET_ANSI_THAI, CHARSET_ANSI_LATIN_II, CHARSET_OEM_LATIN_I
font.colour_index = ?
font.get_biff_record = ?
font.height = 0x00C8 # C8 in Hex (in decimal) = 10 points in height.
font.name = ?
font.outline = ?
font.shadow = ?


Setting the Width of a Cell
import xltw
workbook = xlwt.Workbook()
worksheet = workbook.add_sheet('My Sheet')
worksheet.write(0, 0, 'My Cell Contents')
worksheet.col(0).width = 3333 # 3333 = 1" (one inch).
workbook.save('Excel_Workbook.xls')


Entering a Date into a Cell
import xlwt
import datetime
workbook = xlwt.Workbook()
worksheet = workbook.add_sheet('My Sheet')
style = xlwt.XFStyle()
style.num_format_str = 'M/D/YY' # Other options: D-MMM-YY, D-MMM, MMM-YY, h:mm, h:mm:ss, h:mm, h:mm:ss, M/D/YY h:mm, mm:ss, [h]:mm:ss, mm:ss.0
worksheet.write(0, 0, datetime.datetime.now(), style)
workbook.save('Excel_Workbook.xls')


Adding a Formula to a Cell
import xlwt
workbook = xlwt.Workbook()
worksheet = workbook.add_sheet('My Sheet')
worksheet.write(0, 0, 5) # Outputs 5
worksheet.write(0, 1, 2) # Outputs 2
worksheet.write(1, 0, xlwt.Formula('A1*B1')) # Should output "10" (A1[5] * A2[2])
worksheet.write(1, 1, xlwt.Formula('SUM(A1,B1)')) # Should output "7" (A1[5] + A2[2])
workbook.save('Excel_Workbook.xls')


Adding a Hyperlink to a Cell
import xlwt
workbook = xlwt.Workbook()
worksheet = workbook.add_sheet('My Sheet')
worksheet.write(0, 0, xlwt.Formula('HYPERLINK("http://www.google.com";"Google")')) # Outputs the text "Google" linking to http://www.google.com
workbook.save('Excel_Workbook.xls')


Merging Columns and Rows
import xlwt
workbook = xlwt.Workbook()
worksheet = workbook.add_sheet('My Sheet')
worksheet.write_merge(0, 0, 0, 3, 'First Merge') # Merges row 0's columns 0 through 3.
font = xlwt.Font() # Create Font
font.bold = True # Set font to Bold
style = xlwt.XFStyle() # Create Style
style.font = font # Add Bold Font to Style
worksheet.write_merge(1, 2, 0, 3, 'Second Merge', style) # Merges row 1 through 2's columns 0 through 3.
workbook.save('Excel_Workbook.xls')


Setting the Alignment for the Contents of a Cell
import xlwt
workbook = xlwt.Workbook()
worksheet = workbook.add_sheet('My Sheet')
alignment = xlwt.Alignment() # Create Alignment
alignment.horz = xlwt.Alignment.HORZ_CENTER # May be: HORZ_GENERAL, HORZ_LEFT, HORZ_CENTER, HORZ_RIGHT, HORZ_FILLED, HORZ_JUSTIFIED, HORZ_CENTER_ACROSS_SEL, HORZ_DISTRIBUTED
alignment.vert = xlwt.Alignment.VERT_CENTER # May be: VERT_TOP, VERT_CENTER, VERT_BOTTOM, VERT_JUSTIFIED, VERT_DISTRIBUTED
style = xlwt.XFStyle() # Create Style
style.alignment = alignment # Add Alignment to Style
worksheet.write(0, 0, 'Cell Contents', style)
workbook.save('Excel_Workbook.xls')


Adding Borders to a Cell
# Please note: While I was able to find these constants within the source code, on my system (using LibreOffice,) I was only presented with a solid line, varying from thin to thick; no dotted or dashed lines.
import xlwt
workbook = xlwt.Workbook()
worksheet = workbook.add_sheet('My Sheet')
borders = xlwt.Borders() # Create Borders
borders.left = xlwt.Borders.DASHED # May be: NO_LINE, THIN, MEDIUM, DASHED, DOTTED, THICK, DOUBLE, HAIR, MEDIUM_DASHED, THIN_DASH_DOTTED, MEDIUM_DASH_DOTTED, THIN_DASH_DOT_DOTTED, MEDIUM_DASH_DOT_DOTTED, SLANTED_MEDIUM_DASH_DOTTED, or 0x00 through 0x0D.
borders.right = xlwt.Borders.DASHED
borders.top = xlwt.Borders.DASHED
borders.bottom = xlwt.Borders.DASHED
borders.left_colour = 0x40
borders.right_colour = 0x40
borders.top_colour = 0x40
borders.bottom_colour = 0x40
style = xlwt.XFStyle() # Create Style
style.borders = borders # Add Borders to Style
worksheet.write(0, 0, 'Cell Contents', style)
workbook.save('Excel_Workbook.xls')


Setting the Background Color of a Cell
import xlwt
workbook = xlwt.Workbook()
worksheet = workbook.add_sheet('My Sheet')
pattern = xlwt.Pattern() # Create the Pattern
pattern.pattern = xlwt.Pattern.SOLID_PATTERN # May be: NO_PATTERN, SOLID_PATTERN, or 0x00 through 0x12
pattern.pattern_fore_colour = 5 # May be: 8 through 63. 0 = Black, 1 = White, 2 = Red, 3 = Green, 4 = Blue, 5 = Yellow, 6 = Magenta, 7 = Cyan, 16 = Maroon, 17 = Dark Green, 18 = Dark Blue, 19 = Dark Yellow , almost brown), 20 = Dark Magenta, 21 = Teal, 22 = Light Gray, 23 = Dark Gray, the list goes on...
style = xlwt.XFStyle() # Create the Pattern
style.pattern = pattern # Add Pattern to Style
worksheet.write(0, 0, 'Cell Contents', style)
workbook.save('Excel_Workbook.xls')


TODO: Things Left to Document
- Panes -- separate views which are always in view
- Border Colors (documented above, but not taking effect as it should)
- Border Widths (document above, but not working as expected)
- Protection
- Row Styles
- Zoom / Manification
- WS Props?
Source Code for reference available at: https://secure.simplistix.co.uk/svn/xlwt/trunk/xlwt/


Connect to a PostgreSQL Database
import psycopg2
db = psycopg2.connect(
host = '10.0.0.1',
database = 'my_database',
user = 'my_username',
password = 'my_password'
)

Create a PostgreSQL Cursor (returning values in a Tuple)
import psycopg2
db = psycopg2.connect(
host = '10.0.0.1',
database = 'my_database',
user = 'my_username',
password = 'my_password'
)
cursor = db.cursor()

Create a PostgreSQL Cursor (returning values in a Dict)
import psycopg2
import psycopg2.extras
db = psycopg2.connect(
host = '10.0.0.1',
database = 'my_database',
user = 'my_username',
password = 'my_password'
)
cursor = db.cursor(cursor_factory=psycopg2.extras.DictCursor)

Insert a Row Into a PostgreSQL Table
(Additional Reference: http://www.initd.org/psycopg/docs/usage.html#query-parameters)
import psycopg2
db = psycopg2.connect(
host = '10.0.0.1',
database = 'my_database',
user = 'my_username',
password = 'my_password'
)
cursor = db.cursor()
# Define our values
sku = 'asdf-123'
cost = '7.99'
# Insert into table without escaping values (not recommended)
cursor.execute("INSERT INTO my_table (sku, price) VALUES ('" + sku + "', '" + str(cost) + "')")
# Insert into table, properly escaping values (recommended)
cursor.execute("INSERT INTO my_table (sku, price) VALUES (%s, %s)", (sku, cost,))
# Another example inserting and properly escaping, while casting to appropriate data types
cursor.execute("INSERT INTO my_table (sku, price) VALUES (%(str)s, %(int)s)", (sku, cost,))
# After we've inserted our row, we must then perform a commit() to save the transaction.
db.commit()


Update an Existing Record Within a PostgreSQL Table
import psycopg2
db = psycopg2.connect(
host = '10.0.0.1',
database = 'my_database',
user = 'my_username',
password = 'my_password'
)
cursor = db.cursor()
cursor.execute("UPDATE my_table SET first_name = %s, last_name = %s, email = %s", ('John', 'Doe', 'john@doe.com',))
db.commit()


Retrieve a Row From PostgreSQL Using Various Types of Cursors
import psycopg2
import psycopg2.extras
db = psycopg2.connect(
host = '10.0.0.1',
database = 'my_database',
user = 'my_username',
password = 'my_password'
)
# Default cursor (returns nameless tuple)
tuple_cursor = db.cursor()
tuple_cursor.execute("SELECT * FROM my_table")
my_row = tuple_cursor.fetchone()
print my_row
'''
Will Return:
('John', 'Doe', 'john@doe.com',)
Example Reference:
print my_row[0] # Prints: "John"
'''
# Named Tuple Cursor (returns a tuple which can be referenced by name or offset)
dict_cursor = db.cursor(cursor_factory=psycopg2.extras.NamedTupleCursor)
dict_cursor.execute("SELECT * FROM my_table")
my_row = dict_cursor.fetchone()
print my_row
'''
Will Return:
{'first_name': 'John', 'last_name': 'Doe', 'email': 'john@doe.com'}
Example Reference:
print my_row.first_name # Prints: "John"
print my_row[0] # Prints "John"
'''
# Dict Cursor (returns a Dict which can be referenced via named bracket access, or offset)
dict_cursor = db.cursor(cursor_factory=psycopg2.extras.DictCursor)
dict_cursor.execute("SELECT * FROM my_table")
my_row = dict_cursor.fetchone()
print my_row
'''
Will Return:
{'first_name': 'John', 'last_name': 'Doe', 'email': 'john@doe.com'}
Example Reference:
print my_row['first_name'] # Prints: "John"
print my_row[0] # Prints "John"
'''
# Real Dict Cursor (returns a Dict which can be referenced via named bracket access, or offset)
dict_cursor = db.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
dict_cursor.execute("SELECT * FROM my_table")
my_row = dict_cursor.fetchone()
print my_row
'''
Will return:
{'first_name': 'John', 'last_name': 'Doe', 'email': 'john@doe.com'}
Example Reference:
print my_row['first_name'] # Prints: "John"
'''


Iterate Over a Result Set
import psycopg2
import psycopg2.extras
db = psycopg2.connect(
host = '10.0.0.1',
database = 'my_database',
user = 'my_username',
password = 'my_password'
)
cursor = db.cursor(cursor_factory=psycopg2.extras.RealDictCursor)
cursor.execute("SELECT first_name, email FROM users WHERE last_name = %s", ('Doe',))
for row in cursor:
print '%s: %s' % (row['first_name'], row['email'],)
'''
Will Print:
John: john@doe.com
Jane: jane@doe.com
Billy: billybob@doe.com
'''