Pharo

Exception Handling

If you try and perform an piece of code that might lead to an exception then to catch / manage that you can do something like this :

[1 / 0] on: ZeroDivide do: [ :e | Transcript show: 'You have an error' ].

Place the code that might throw an exception in a block and then using the on: do: method state the exception(s) that you want to handle followed by a block that (takes the exception as an argument) and specifies what you then want to do.

To return a thing from / resume after an exception then :-

[1 / 0] on: Error do: [ :e | e return: 2 ].

[1 / 0] on: Error do: [ :e | e resume ].

For more helpful stuff see this old video from James Robinson - here.

Dates

The processing of dates in any programming language / environment can be difficult - here are some examples using Pharo :-

'21/112021' asDate.<<21 November 2021>>
'21 September, 2021' asDate.<<21 September 2021>>
'2021-11-21' asDate.<<21 September 2021>>
'11/21/2021' asDate.<<21 September 2021>>

It should be noted that the last example above uses the format mm/dd/yyyy. If we tried to process a date as dd/mm/yyyy then we get an exception. To set the date pattern :-

Date readFrom: '21/11/2021' readStream pattern: 'dd/mm/yy'.<<21 November 2021>>

`For other date patterns see the class comments for the DateParser class.

A few notes about some Pharo classes that I have created to assist in the wider development of other applications.

CT-CSV

A small class to load a CSV file (with headers). Data is stored as an OrderedCollection containing a set of dictionaries - one for each line -> keys are the header values and therefore are assumed to be the first row in the file.

Methods are provided to load data from a csv file and write data to a csv file.

An additional method has been added to the Dictionary class to facilitate the process :-

collectKeysAsStrings: aBlock 

	"Evaluate aBlock with each of my keys as the argument.  Collect the
	resulting keys as strings into a collection. Answer with the new
	collection."
	| index newCollection |
	newCollection := Array new: self size.
	index := 0.
	self keysDo: [ :each |
		newCollection at: (index := index + 1) put: ( each asString ) ].

	^ newCollection

CT-DataFrame

A minimal implementation (inspired by 'R') of a dataframe object. An intro can be found (in terms of 'R') here. The code can be found on github.

The original intent is to provide a means of filtering / grouping data and (by providing a suitable set of methods) have an interface that other services can make use of - for example - charting / visualizations.

In this initial implementation the dataframe takes a set of row objects (dictionary objects - from CTDBx or CTCSV) as an OrderedCollection and stores these in the instance variable dataset. Various select methods can then be used to filter the data into a resultset - the resultset is then used to summarize the data or perform specific calculations on specific fields - mean / sum / standard deviation (more will be added). Some rudimentary grouping functionality does also exist. The data (filtered / grouped) can also be returned as a JSON string - in the series instance variable.

To load data into the dataframe on the basis of a database query :-

It is also possible to load data into the dataframe from a csv file. In the example here we use a groupBy and pass the result into a JSON string.

| csv df |
csv := CTCSV new.
df := CTDataFrame new.
csv loadFromCSVFile: '/Users/richardpillar/temp/income.csv'.
df dataset: csv data; selectEquals: 'Year' with: 13 and: 'Month'  with: 1; groupBy: 'Week'; groupsetToJsonString.

CT-DBx

A simple database interface enabling row-data to be retrieved and stored as collections of dictionary objects. The code can be found on github.

There are two main objects - CTDBxQuery and CTDBxResult. A custom DSL is used to express the query that you might want to perform - for example :-

q := CTDBxQuery new.
q queryTable: 'CTDBxTableCars'; dbSearch: { { #name -> 'Richard' . #age -> 21 } . { #name -> #( #orderby desc ) . #limit -> 1 } }.
q inspect.

This will produce the following SQL query :-

select model,year from cars  where  name='Richard' and  age='21' order by name desc limit 1;

Various helper methods are provided such as dbSearch:, dbSearchAll, dbUpdate: and many more.

This means that you can run the database queries in the following way :-

| rs q |
rs := CTDBxResult new.
rs conn: ( UDBCSQLite3Connection on: '/Users/richardpillar/temp/test.db' ).
rs conn open.

q := CTDBxQuery new.
q queryTable: 'CTDBxTableContacts'; dbSearchAll.

rs processSearchQuery: q queryString with: q queryTableObject dbTableFields.

The result field (in the CTDBxResult object) will hold a collection of dictionaries representing the table rows that have been retrievd.

There has also been an attempt to make it possible, within a CTDBxResultTable*, to express relationships between tables. It should be noted that this is only an early attempt (and may change). One disadvantage is that each relationship is expressed as a separate query rather than as a join. Here is an example method where we are performing a query to retrieve performance data based on the current data within a CTDBxResultTableCars object. :-

rPerformance   
    
| rs |
self query queryTable 'CTDBxTableSchemaPerformance'; dbSearch: { { #name -> self model} }.
rs := CTDBxResultTablePerformance new.
rs conn: self conn.
rs resultset: ( rs procesSearchQuery: query queryString ).
^ rs.

For more info on this package please see the dedicated CTDBx page here.